Coding Pills: clipboard ring and toggle comment

Unfortunally I’ve got the flue, so I’m here at home, alone (not so alone, cats are with me), with some time to spend. Fortunally I still have a blog where to write! 🙂

Sorry guys, I’ve been very busy these times and that’s the reason why I took so long to write again. But I’m here and with your big surprise (or not) I’m writing in English.

So, just to start, I wanna write a little post with two very useful tips that I’ve found many programmers doesn’t know, but I think they should.

And those tips are:

  • Clipboard ring
  • Toggle comment

Clipboard Ring

Microsoft calls it Clipboard Ring but, for example the smart guys at JetBrains call it Clipboard History.

What’s it? Actually Visual Studio and for example IntelliJ remembers all code you have copied not only the last one.

With Ctrl+V (Cmd+V) you just obtain the last copied code, but with Ctrl+Shift+V (Windows) or Cmd+Shift+V (Mac) you could cycle around all the previous copies you have done!

Toggle Comment

The toggle comment could be usefull for fast prototyping or fast debugging when you are not sure which choice to do and are evaluating between two alternatives leaving code cleaning for the future.

The block is that:

//* this is your toggle (state on)
<uncommented code>
/*/
<commented code>
//*/

-----

/* this is your toggle (state off)
<commented code>
/*/
<uncommented code>
//*/

And here a live example:

Coding Pills: clipboard ring and toggle comment

Convertire una combobox in checkbox con jQuery

Se non avete accesso all’html di un CMS e volete cambiare una textbox in una checkbox, ecco il codice jQuery che ve lo fa fare!
Enjoy!!!

<!DOCTYPE html>
<html>
	<head>
		<meta charset="UTF-8">
		<script type="text/javascript" src="https://code.jquery.com/jquery-1.11.2.min.js"></script>
		<script src="https://code.jquery.com/jquery-migrate-1.2.1.js"></script>
	</head>
	<body>
		<select size="1" name="mySelect" id="mySelect">
			<option selected="selected" value="Any">Hello</option>
			<option value="1">Questo è una</option>
			<option value="2">Textbox</option>
			<option value="3">In realtà :O)</option>
		</select>			
	</body>
</html>

<script type="text/javascript">
$(function(){
	//$(".main_container select").selectbox();
	$('select').each(function(i, select){
	    var $select = $(select);
	    $select.find('option').each(function(j, option){
	        var $option = $(option);
	        // Create a radio:
	        var $radio = $('<input type="radio" />');
	        // Set name and value:
	        $radio.attr('name', $select.attr('name')).attr('value', $option.val());
	        // Set checked if the option was selected
	        if ($option.attr('selected')) $radio.attr('checked', 'checked');
	        
	        // Insert radio before select box:
	        $select.before($radio);

	        //wrap radio in div
	        $radio.wrap( "<div class='radio_button'></div>" );
	        
	        // Insert a label:
	        $radio.after(
	          $("<label />").text($option.text())
	        );
	        // Insert a <br />:
	        //$select.before("<br/>");
	    });
	    $select.remove();
	});
})
</script>

Salvatelo come file Html e provatelo 😉

Convertire una combobox in checkbox con jQuery

NVCC compile PTX with virtual code or for specific architecture

Se compiliamo con NVCC in modo che utilizzi un Virtual Code possiamo utilizzare il programma su qualunque architettura di GPU però abbiamo un delay allo startup dell’applicazione, come descritto a pagina 25 del manuale di NVCC di CUDA 7.

CUDA_Compiler_Driver_NVCC.pdf

Che si trova nel seguente direttorio: C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v7.0\doc\pdf

“By specifying a virtual code architecture instead of a real GPU, nvcc postpones theassembly of PTX code until application runtime, at which the target GPU is exactlyknown. For instance, the command below allows generation of exactly matching GPUbinary code, when the application is launched on an sm_20 or later architecture.nvcc x.cu –gpu-architecture=compute_20 –gpu-code=compute_20The disadvantage of just in time compilation is increased application startup delay,but this can be alleviated by letting the CUDA driver use a compilation cache (refer to”Section 3.1.1.2. Just-in-Time Compilation” of CUDA C Programming Guide) which ispersistent over multiple runs of the applications.”

 

 

NVCC compile PTX with virtual code or for specific architecture

Compilare le OpenCV 3.0 con CUDA 7 e VisualStudio 2013 per x64

OpenCV 3.0

Occi vi mostrerò come compilare le OpenCV con il supporto per le schede grafiche NVIDIA.

Prima di tutto scarichiamo le OpenCV 3.0 dal loro repository su GitHub: https://github.com/Itseez/opencv.

Installiamo i sorgenti dove più ci piace, per questo esempio io le metterò sul Desktop.

Poi scarichiamo CMake che al momento della stesura di questo articolo è alla versione 3.3.0. Installiamolo. Io ho utilizzato il Win32 Installer.

Scarichiamo ovviamente il CUDA toolkit dal sito della NVIDIA e installiamolo. Al momento di stesura dell’articolo siamo alla versione 7.0. Io ho installato il Windows 8.1 local installer.

Lanciamo CMake e andiamo a dare il percorso dei sorgenti delle OpenCV e della cartella dove vogliamo generare la solution di Visual Studio 2013 per la compilazione:

cmake

 

 

Spuntare “Grouped” e “Advanced”, cliccare su “Configure” e scegliere “Visual Studio 12 2013 Win64” e poi “Finished” e aspettare il termine.

cmake2

Al termine dovremmo vedere “configure done” scritto nella finestra di console di CMake ma la parte centrale probabilmente verrà evidenziata di rosso:

cmake3

 

Espandiamo il nodo BUILD nella finestra rossa ed eliminiamo la spunta da BUILD_DOCS.

Nel mio caso l’errore deo Config era il fatto che non trova Doxygen. Semplicemente così dovremmo risolvere il conflitto.

Però io ho eliminato anche la generazione degli esempi per velocizzare un po’ la compilazione togliendo la spunta da BUILD_EXAMPLES

cmake_build

Controlliamo che nel nodo CMAKE il valore di CMAKE_LINKER sia il linker di Visual Studio 2013 (v12).

cmake_linker

Controlliamo che nel nodo CUDA non sia selezionato (eventualmente togliamo la sputa da) CUDA_ATTACH_VS_BUILD_RULE_TO_CUDA_FILE.

Questo flag server se si eseguono Build in parallelo.

cmake_cuda

Nel nodo WITH controlliamo che siano selezionati (altrimnenti mettiamo la spunta anche in)  WITH_CUBLAS, WITH_CUDA, WITH_OPENGL.

Intanto che compiliamo con CUDA compiliamo anche le CUDA Basic Linear Algebra Subroutines (cuBLAS) e il supporto per le OPEN_GL.

cmake_with

Ripremiamo “Configure” per fare il refresh e per vedere che questa volta la finestra centrale sia “bianca”.

Vi ricordo che ora è bianca perchè abbiamo tolto la spunta da BUILD_DOCS che cercava Doxygen e non per le altre configurazioni fatte.

cmake_ok

Se la finestra centrale è bianca e abbiamo “Configure done” allora è tutto Ok e possiamo cliccare su “Generate” per creare la soluzione Visual Studio.

cmake_generate

A questo punto dopo “Generating done” possiamo chiudere CMake e andare ad aprire la solution nella cartella dove abbiamo detto di crearla che nel mio caso è: C:\Users\fabio\Desktop\buildCuda

cmake_build_dir

Aprite la solutione, lanciate ALL_BUILD in Debug o Release e andate a prendere un caffè 🙂

Non vi è bastato vero il caffè? Sul mio PC impiega circa un’ora a Build (i7, 12GB ram, SSD HD).

vs13_cv3_debug

Una volta finito di Compilare lanciate la INSTALL.

Lanciate INSTALL che trovate in (CMakeTargets) per avere nella directory “install” le dll e librerie appena compilate

vs13_cv3_debug_install

vs13_cv3_debug_install_end

Ecco dove troverete le vostre DLL e LIB delle OpenCV compilate con CUDA

vs13_cv3_debug_install_end_dir

Io ora ho compilato in Debug.

Lanciando anche la compilazione in Release vedrete insieme le librerie di debug (*d.dll, *d.lib) assieme a quelle di release (*.dll, *.lib).

OpenCV 2.4.9

Per le OpenCV 2.4.9 il procedimento è praticamente identico, però ho dovuto impostare il CUDA_GENERATION dicendo esplicitamente la mia architettura ‘Kepler

cmake_cuda_generation

 

Altrimenti avevo l’errore di compilazione: Unsupported gpu architecture ‘compute_11’

Ho letto comunque che se si setta l’architettura specifica anche con le OpenCV 3.0 la compilazione è molto più veloce perchè non vengono compilati i file .cu per le altre architatture.

Senza specificarlo invece vengono compilati i .cu per tutte le architatture (GPU): Kepler, Fermi, etc…

E ho dovuto modificare il file NCV.cu (opencv-2.4.9\modules\gpu\src\nvidia\core\NCV.cu), andando ad includere il package “algorithm”:

#include <algorithm>

ncv.cu

Altrimenti mi dava l’errore: ‘max’ undefined error.

Compilare le OpenCV 3.0 con CUDA 7 e VisualStudio 2013 per x64

Debugging .NET application con WinDbg

E’ possibile creare un file minidump anche per applicazioni .NET nello stesso modo descritto nell’articolo per le applicaizoni native:

http://www.versionestabile.it/blog/dubugging-with-windbg/

Per le applicazioni .NET è più difficile avere la riga di codice esatta, soprattutto se non si è tenuto il file .pdb della versione che ha fatto il “crash” a casa del cliente e non vengono caricati correttamente anche i symboli delle classi .NET relative al Framework con cui è stato compilato il programma in question.

Per prima cosa lanciare il caricamento del framework

.loadby sos clr

Comunque anche se si dispone solo del file .dump (vedere come generarlo nell’articolo citato sopra) se lo si apre con WinDBG e si analizzano al suo interno le eccezioni con il comando

!analyze -v

Si può vedere lo stack trace che ci porta al punto di programma incriminato.

Vediamo un esempio.

Il programma C# del nostro esempio è il seguente:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace WinDbgCrashTest
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            badMethod();
        }

        private void badMethod() {
            Object o = null;
            String s = o.ToString();
        }
    }
}

Se lo si lancia andrà in Crash immediato.

Apriamo il suo minidump con WinDBG e lanciamo !analyze -v

Lancirare WinDbg come amministratore in modo che possa scaricare (dal sito di Microsoft) nelle cartelle di sistema i simboli che eventualmente non trova in locale.

Ecco il risultato:

windbg_net_crash1
Anche se non è riuscito a caricare i simboli

crash_net_windbg_0
ci dice che alla riga 2 del metodo badMethod all’interno della classe Form1 si è verificata l’eccezione!

Se diamo a WinDBG il path del .pdb e dei sorgenti che fanno riferimento a quell’eseguibile con il comando

!clrstack

Abbiamo anche più info: il file e la riga dove è avvenuta l’eccezione.
crash_net_windbg

Debugging .NET application con WinDbg

Creare un webservice a partire dal suo wsdl

Vi hanno chiesto di fare un Web Service che rispetti una certa interfaccia wsdl e vi hanno dato solo il file .wsdl?

Niente paura, partite da qui:

1. Aprite il command prompt di visual studio

2. Andate nella directory che contiene il vostro file .wsdl chiamiamolo webservice.wsdl

3. Eseguite il comando

wsdl.exe webservice.wsdl /l:CS /serverInterface

dove /l da il linguaggio da utilizzare (CS=C#, VB=Visual Basic).

Verrà generato il vile .cs da importare nel vostro progetto WebService.

Non dovrete fare altro che andare a dire alla classe del vostro WebService di implementare tale interfaccia.

Buon lavoro!

Creare un webservice a partire dal suo wsdl

C# virtual method

Cosa significa dichiarare un methodo “virtual”?

Se un metodo virtuale viene invocato è il tipo di classe a run-time che determina quale metodo verrà invocato.

In un metodo non virutale è, al contrario, il tipo di classe a compile-time che determina quale metodo verrà invocato.

Ad esempio se abbiamo una classe padre come la seguente

namespace VirtaulMethodExamples
{
    public class Father
    {
        public virtual string getVirtaulName() {
            return "Father.getVirtaulName()";
        }

        public string getName() {
            return "Father.getName()";
        }
    }
}

e una classe figlia da essa derivata

namespace VirtaulMethodExamples
{
    public class Child: Father
    {
        public override string getVirtaulName()
        {
            return "Child.getVirtaulName()";
        }

        public new string getName()
        {
            return "Child.getName()";
        }
    }
}

Nel seguente schenario

Child child = new Child();
Father father = child;

Console.WriteLine(child.getVirtaulName());
Console.WriteLine(child.getName());
Console.WriteLine(father.getVirtaulName());
Console.WriteLine(father.getName());

verrà scritto a console

Child.getVirtaulName()
Child.getName()
Child.getVirtaulName()
Father.getName()

La penultima riga richiamando un metodo virtual guardal al tipo di classe a run-time (Child) e non al tipo di classe a compile-time (Father) per invocare il metodo.

Contrariamente, l’ultima riga guarda al tipo di classe a compile-time (Father) per invocare il metodo non virtual.

Da notare l’uso della parola chiave “new” nella dichiarazione del metodo getName() nella classe Child per non avere un warning di compilazione in quanto il metodo getName di Child nasconde il metodo getName di Father.

C# virtual method

Logging Framework: log4net

Il Log è una parte importante di molti programmi.
Esiste un Framework molto valido, dal lontano 1996 su linguaggio Java, che permette in sintesi:
  • Logging su più canali
  • Gerarchie di log
  • Filtri
  • Configurabile da file (con watcher)
Il sito ufficiale è: http://logging.apache.org/log4net/
Ecco un esempio di log4net.config file:

<!-- This section contains the log4net configuration settings -->
<log4net>
   <!-- File Appender -->
   <appender name="LogFileAppender" type="log4net.Appender.FileAppender">
      <file value="log-file.txt" />
      <sppendToFile value="true" />
      <layout type="log4net.Layout.PatternLayout">
         <header value="[Header]&#xD;&#xA;" />
         <footer value="[Footer]&#xD;&#xA;" />
         <conversionPattern value="%date [%thread] %-5level %logger (%property{log4net:HostName}) [%ndc] - %message%newline" />
      </layout>
   </appender>
   <!-- Rolling File! 🙂 -->
   <appender name="RollingFileAppender" type="log4net.Appender.RollingFileAppender">
      <file value="example.log" />
      <appendToFile value="true" />
      <maximumFileSize value="100KB" />
      <maxSizeRollBackups value="2" />
      <layout type="log4net.Layout.PatternLayout">
         <conversionPattern value="%level %thread %logger - %message%newline" />
      </layout>
   </appender>
   <!-- Console Appender -->
   <!-- appender name="ConsoleAppender" type="log4net.Appender.ConsoleAppender" >
 <layout type="log4net.Layout.PatternLayout">
 <conversionPattern value="%date [%thread] %-5level %logger [%ndc] - %message%newline" />
 </layout>
 </appender -->
   <!-- EventID Appender -->
   <!--
 Also note that if your program is called app.exe, then you need an eventlog source called app.exe.
 If this does not exist, then Log4net will attempt to create it, but that requires Admin rights, 
 so you may need to run your program as admin at least once in order to create this event source. 
 To avoid this, the event source would normally be created as part of the installation procedure which 
 would already be running as admin.
 -->
   <appender name="EventLogAppender" type="log4net.Appender.EventLogAppender">
      <!--applicationName value="log4net_lab" /-->
      <layout type="log4net.Layout.PatternLayout">
         <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline" />
      </layout>
   </appender>
   <!-- Database Appender -->
   <!-- Example of how to configure the AdoNetAppender to connect to MS SQL Server -->
   <appender name="ADONetAppender_SqlServer" type="log4net.Appender.AdoNetAppender">
      <bufferSize value="1" />
      <connectionType value="System.Data.SqlClient.SqlConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
      <connectionString value="data source=your_host catalog=your_database;integrated security=false;persist security info=True;User ID=your_user;Password=your_password" />
      <commandText value="INSERT INTO Log ([Date],[Thread],[Level],[Logger],[Message]) VALUES (@log_date, @thread, @log_level, @logger, @message)" />
      <parameter>
         <parameterName value="@log_date" />
         <dbType value="DateTime" />
         <!-- 
 <layout type="log4net.Layout.PatternLayout">
 <conversionPattern value="%date{yyyy'-'MM'-'dd HH':'mm':'ss'.'fff}" />
 </layout> 
 -->
         <layout type="log4net.Layout.RawTimeStampLayout" />
      </parameter>
      <parameter>
         <parameterName value="@thread" />
         <dbType value="String" />
         <size value="255" />
         <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%thread" />
         </layout>
      </parameter>
      <parameter>
         <parameterName value="@log_level" />
         <dbType value="String" />
         <size value="50" />
         <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%level" />
         </layout>
      </parameter>
      <parameter>
         <parameterName value="@logger" />
         <dbType value="String" />
         <size value="255" />
         <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%logger" />
         </layout>
      </parameter>
      <parameter>
         <parameterName value="@message" />
         <dbType value="String" />
         <size value="4000" />
         <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%message" />
         </layout>
      </parameter>
   </appender>
   <!-- SQLite Appender -->
   <appender name="AdoNetAppender_SQLite" type="log4net.Appender.AdoNetAppender">
      <bufferSize value="100" />
      <connectionType value="System.Data.SQLite.SQLiteConnection, System.Data.SQLite, Version=1.0.96.0, Culture=neutral, PublicKeyToken=db937bc2d44ff139" />
      <connectionString value="Data Source=log4net.db3;Version=3;" />
      <commandText value="INSERT INTO Log (Date, Level, Logger, Message) VALUES (@Date, @Level, @Logger, @Message)" />
      <parameter>
         <parameterName value="@Date" />
         <dbType value="DateTime" />
         <layout type="log4net.Layout.RawTimeStampLayout" />
      </parameter>
      <parameter>
         <parameterName value="@Level" />
         <dbType value="String" />
         <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%level" />
         </layout>
      </parameter>
      <parameter>
         <parameterName value="@Logger" />
         <dbType value="String" />
         <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%logger" />
         </layout>
      </parameter>
      <parameter>
         <parameterName value="@Message" />
         <dbType value="String" />
         <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%message" />
         </layout>
      </parameter>
   </appender>
   <!-- Assign Appenders -->
   <root>
      <level value="DEBUG" />
      <!--level value="All"/-->
      <appender-ref ref="LogFileAppender" />
      <appender-ref ref="RollingFileAppender" />
      <!--appender-ref ref="ConsoleAppender"/-->
      <appender-ref ref="EventLogAppender" />
      <!--appender-ref ref="ADONetAppender_SqlServer"/-->
      <appender-ref ref="AdoNetAppender_SQLite" />
   </root>
   <!-- Print only messages of level WARN or above in the package Com.Foo -->
   <logger name="Com.Foo">
      <level value="WARN" />
   </logger>
</log4net>
Logging Framework: log4net

Start versioning with GIT

1. Git Init

Fare la init nella cartella di progetto per avere il repository locare
git_local_init

 

NOTA: Inserire subito l’ignore file in modo da non committare tutti i file compilati!

Esempio: .gitignore

bin
Bin
obj
*.suo
*.pdb
Thumbs.db

2. Commit => Master

Fare la commit dei file nel master locale
git_commit_master

3. Bare repo

Creare un repository “bare” in remoto o in locale su un disco esterno (per esempio)

In locale di solito le cartelle “bare” hanno come suffisso il .git
git_bare_1

Fare la push dal master locale al repository “bare”

git_push_1
git_push_2
git_push_3

4. Start Coding, Committing and Pushing 😀

Start versioning with GIT