skolima

Build systems for the .NET Framework

2012-02-06T12:12:00.000-08:00

When on 13th of February 2002 Microsoft released the first stable version of the .NET Framework,the ecosystem lacked an officially supported build platform. However, since early betas wereavailable short after July 2000 Professional Developers Conference, a native solution – NAnt – emerged in August 2001,three months before the framework itself became officially available. But it was not until7th of November 2005 that Microsoft presented it’s own tool : MSBuild. For two years the competingsystems coexisted in the .NET world, as MSBuild was a new, and relatively unpolished, product. When on 19thof November 2007 a second version of MSBuild (labeled 3.5, to match the .NET Framework versionit accompanied) was released, it brought multiple improvements that developers have asked for. The community’s focus switchedfrom NAnt to the Microsoft solution, and NAnt 0.86-beta1, released on 8th of December 2007, was the last releasefor almost three years. Although NAnt development started again in April 2010, this long stagnationhas led many of it’s previous users to believe the Open Source solution to be abandoned.

MSBuild 4.0 offers multiple improvements over NAnt: it ships with packaged Target files for commonly used project types,in accordance with “convention over configuration” paradigm; it has an ever-growing collection of community Taskswhich perform various commonly executed build operations; it supports parallel builds; it integrates withTeam Build (a Continuous Integration component of Microsoft Team Foundation Server) and other CI systems;and most importantly, it is used internally by Visual Studio, which presents most build options through a graphical user interface– developers creating a build project with the help of an IDE may not even be aware that MSBuild is being used underneath.

Nowadays MSBuild is the de facto standard tool for build automation in the .NET ecosystem. However, multipleprojects still employ a legacy NAnt build system – the main problems preventing migration being complexity of theexisting build infrastructure and supporting Mono, which, until 2.4 (released on 8th of December 2009),lacked an MSBuild implementation. Although the Mono version of MSBuild 3.5 is now relatively complete,version 4.0 is still virtually non-existent.

Pre-existing Solutions

Apart from the two already mentioned build platforms, there are several others. The first of them, dating way back into the Unix times, is called Autotools, officially known as the GNU Build System. The core of Autotools – make – was released in 1997. Although this system is widely used by projects developed in C or C++, such as the Mono runtime engine, it has no built-in support for .NET specific compilers, requiring a large amount of custom per-project work by developers. It also has a reputation of being convoluted and unfriendly, although extremely powerful.

Developers and users of other build system, such as CMake, Ant or Maven, had on numerous occasions undertaken efforts to enhance .NET support. Especially Maven community has spawned numerous .NET-targeted clones – NPanday, Byldan, NMaven – none of which has gained any traction. The only exception seems to be maven-dotnet-plugin, which delegates the build process back to MSBuild.

An interesting new tool that is worth mentioning is FAKE – F# Make. Although still very much an experimental project, started on 30th of March 2009, this tool is under active development by several contributors. It borrows heavily from ideas explored by Rake (written in and for the needs of projects in the ruby language), and allows users to describe the build process configuration in the same language they are using to write their code.

This post looks in depth at three existing build platforms employed on the .NET Framework: NAnt – which used to be the de facto standard, Microsoft Build – the officially supported tool, and FAKE – an interesting build tool employing an entirely different build description paradigm.

All three tools present the same basic functionality of a build platform: a project file contains tasks, enclosed in targets, which may have specified dependencies upon other targets. During the build process, those targets are first sorted topologically and then tasks within each target are executed in sequence. However, the structure of a project file differs greatly between tools.

NAnt

When Stefan Bodewig announced first official Ant release on 19th July 2000, the project already had undergone over a year of public development as part of the Tomcat servlet container, and had been used for a year before that as an internal tool at Sun Microsystems (under the name Another Neat Tool). In August 2001, Gerry Shaw made a decision to base the new .NET build platform on the existing Ant file syntax (initial code for .NET Beta 1 Ant clone was written by David Buksbaum of Hazware and released under the name of XBuild). Keeping with the open source tradition of self-recursive names, he aptly named this new tool NAnt, from NAnt is not Ant.

After almost ten years of separate development, NAnt’s Project.build is still difficult to distinguish from Ant’s build.xml file; the only obvious giveaway being the use of C#’s csc compiler task instead of Java’s javac. An absolutely minimal working NAnt build file looks as follows:

<project default="build">
  <target name="build">
    <csc target="exe" output="Hello.exe">
      <sources>
        <include name="*.cs" />
      </sources>
    </csc>
  </target>
</project>

This short example contains a single target (build), which in turn contains a single task, with a simple nested fileset. Executing this file starts the default target, which invokes the csc task to compile the code using the appropriate C# compiler.

NAnt projects consist of several basic entities: task, types, properties, functions and loggers. Tasks wrap fundamental operations, such as copying a file, performing source control operations or invoking the compiler. Types represent strongly typed parameters, are aware of their content and validate their correctness on creation. A fileset is perhaps the most often used type – it is a lazily evaluated collection of files (the sources element in the example above is a fileset). Properties can be used for storing text values that are used multiple times. They are evaluated in the place of their declaration. Functions, along with operators, can be used in any attribute value, and are evaluated when the attribute is read (usually upon task execution). Loggers are usually employed for reporting build progress to the user through various front-ends, but can also serve for tracking project execution for other purposes. NAnt ships with a large collection of predefined elements, additional ones can be either loaded from external assemblies or defined in-line using a script task. Scripts can be written in any .NET language that has a System.CodeDom.Compiler.CodeDomProvider available.

A more advanced example, showing properties, functions and global tasks (not enclosed inside a target):

<project>
  <property name="is-mono"
    value="${string::contains(framework::get-target-framework(), 'mono')}" />
  <property name="runtime-engine"
    value="${framework::get-runtime-engine(framework::get-target-framework()) }" />
  <echo message="Checking Mono version" if="${is-mono}"/>
  <exec program="${runtime-engine}" commandline="-V" if="${is-mono}" />
  <echo message="Using non-Mono runtime engine: '${runtime-engine}'"
    unless="${is-mono}" />
</project>

Global tasks are always executed in the order they are declared and are used for setting up the project. Functions and properties are evaluated inside ${} blocks, they can be distinguished by the fact that functions use :: to separate the prefix from the function name. Also visible in this example are the if and unless attributes which are available on every task and are used for conditional task execution.

While NAnt inherited Ant’s mature syntax, along with such brilliant constructs as a distinction between * (match in current directory) and ** (recursive directory match) for file inclusion/exclusion, it also inherited Ant’s deficiencies. The most glaring one is the inherent single threaded nature of the build process – although the engine itself can be relatively easily extended to invoke targets in parallel, existing build files rely on targets being executed sequentially.

Microsoft Build

MSBuild 2.0 (releases are numbered after the Microsoft .NET Framework they accompany, thus the first release is labeled 2.0, second – 3.5 and third – 4.0) was released on the 7th of November, 2005, as part of the Microsoft .NET 2.0 release. It came bundled as the default build tool for Visual Studio 2005. MSBuild’s initial design was similar to NAnt’s, but because at that time company policy forbade Microsoft employees from looking at the implementation of open source solutions (in order to prevent intellectual property violation claims), it does differ in many subtle ways.

Visual Studio 2005 used Microsoft Build for compiling C# and Visual Basic projects, all other solution types were still handled by the built-in mechanisms inherited from the 2003 release. Before version 2.0 MSBuild was not used internally by Microsoft, but as soon as it had reached the Release To Manufacturing stage, intense build process conversion effort has been launched, and by the early November 2005 it was already building about 40% of the Visual Studio project itself. This internal version added support for parallel builds (released to the general audience on 19th November 2007 as 3.5) and compiled all types of projects available in Visual Studio, including Visual C++ (this last feature was released on 12th April 2010 as part of 4.0 version). Another important improvement released with Visual Studio 2010 was a graphical debugging tool.

A minimalistic MSBuild’s Project.proj looks as follows:

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003"
  DefaultTargets="Build">
  <Target Name="Build">
    <ItemGroup>
      <Compile Include="*.cs" />
    </ItemGroup>
    <CSC Sources="@(Compile)" OutputAssembly="Hello.exe"/>
  </Target>
</Project>

Although a different naming convention is used (uppercase identifiers instead of lowercase), this file shows great similarity to NAnt’s Project.build. It contains a single target, which in turn contains an item group and a task. The namespace definition is required and uses the same schema regardless of the MSBuild version. Executing this file starts the default target, named Build, which calls the CSC task to compile the code. File collections (and item groups in general) can be declared at target or project level, but (unlike NAnt) cannot be nested inside tasks (some tasks allow for embedding item groups and property groups, but this is rare behavior). Prior to version 4.0, items could not be modified once declared.

Despite being a valid MSBuild file, the above example would not be recognized by Visual Studio (and by most .NET developers). Instead of requiring the user to describe the whole build process verbosely, MSBuild offers .target files which allow “convention over configuration” approach to build process : user only specifies those settings and actions that differ from the default ones. MSBuild projects use .proj extension for generic build scripts, and language-specific extensions are used for files importing specific .targets (for example .csproj for C# projects). Thus, a minimal Project.csproj might be written as:

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup>
    <Compile Include="*.cs" />
  </ItemGroup>
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
</Project>

By replacing an explicit invocation of the CSC task with an Import directive, this file inherits the whole build pipeline defined for Visual Studio, including automatic dependency tracking (should one declare Reference items), graphical user interface for configuring the build, targets for cleaning and rebuilding the assembly, and standardized extension points.

Basic entities in a MSBuild project are properties, items and tasks. Properties represent simple values. Items are untyped key-value collections, mostly used to represent files. Both types are evaluated as soon as they are encountered. They must be wrapped in groups, but this only allows them to share a Condition: properties cannot be bundled and items are always grouped by name (in the example above the ItemGroup generates items named Compile, one for each matching file). MSBuild has a mechanism named batching that splits items sharing a name according to a specified metadata value – when this is used, a task defined once will be executed for each batch of items separately. Item definitions allow setting default item metadata values. MSBuild, like NAnt, distinguishes between * (match inside current folder) and ** (recursive directory match). Loggers can be used for tracking project execution, but they must be attached from command line. There is a quite extensive task collection available out of the box, many of them are direct replacements for NAnt tasks. Since 4.0 it is also possible to define a task in-line with the help of UsingTask.

An example of using functions for evaluating task conditions (this example does not work as of Mono 2.10 because functions are still not implemented):

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003"
  InitialTargets="Info">
  <PropertyGroup>
    <IsMono>$(MSBuildBinPath.Contains('mono'))</IsMono>
    <RuntimeEngine>$(MSBuildBinPath)/../../../bin/mono</RuntimeEngine>
  </PropertyGroup>
  <Target Name="Info">
    <Message Text="Checking Mono version" Condition="$(IsMono)"/>
    <Exec Command="$(RuntimeEngine) -V" Condition="$(IsMono)"/>
    <Message Text="Using non-Mono runtime engine: '$(MSBuildBinPath)'"
      Condition="!$(IsMono)"/>
  </Target>
</Project>

Property values and functions are evaluated inside $() blocks, basic operators (such as ==) are also recognized outside of those markers. @() syntax is used for referencing collections of items and %() triggers the batching mode using item metadata. MSBuild 4.0 is keeping track of the actual underlying type of each property value and is able to invoke any .NET instance methods defined on such an object – however, because of security concerns, only methods marked as safe (number/date/string/version manipulation and file system read-only access) are available in scripts (this security mechanism can be disabled by setting the environment variable MSBUILDENABLEALLPROPERTYFUNCTIONS to 1). The syntax for method invocation comes from PowerShell – instance methods are called with a simple Value.Method(), while static methods can be invoked with [Full.Type.Name]::Method().

The MSBuild syntax draws heavily from NAnt and should feel quite familiar for any developer once one grasps how items differ from NAnt’s strongly typed collections. The tool is under active development, has extensive support from both Microsoft and the community, and – since Mono 2.4 was released on 8th of December 2009 – is usable as a cross-platform build system.

FAKE

Fake was published by Steffen Forkmann on the 1st of April, 2009. His goal was to create a build platform using the same language he wrote his programs in – F# (this trend is also observed in Ruby, Python and other languages which allow executable domain-specific languages to be defined at the language level). Three years later, Fake still remains more of an academic exercise than a widely deployed tool, but it does explore a very interesting approach to build management. Fake executes its scripts through the F# interpreter, extending the syntax of the language with three simple additions:defining build steps (Target? TargetName),declaring coupling between targets (For? TargetName <- Dependency? AnotherTargetName) and specification of default targets (Run? TargetName).

A basic build.fsx might look as shown in the listing below:

#I @"tools\FAKE"
#r "FakeLib.dll"
open Fake

Target? Default <-
  fun _ ->
    let appReferences  = !+ @"**.csproj" |> Scan
    let apps = MSBuildRelease @".\build\" "Build" appReferences
    Log "AppBuild-Output: " apps

Run? Default

First three lines import the Fake namespace from the FakeLib.dll file in directory tools\FAKE. Following them is a target definition, with a fileset wildcard match pipelined (using F#’s |> operator) to the Scan function, then a MSBuildRelease task invocation, log output, and finally – declaration of the default target. It should be noted here that Fake does not have built-in tasks for compiling code – it relies on the presence of MSBuild instead. There is also no need for a special in-line task definition syntax, as arbitrary F# code can be embedded anywhere in the script. This can be seen in the following example:

#I @"tools\FAKE"
#r "FakeLib.dll"
open Fake
open System

let isMono = Type.GetType ("Mono.Runtime") <> null
let stringType = Type.GetType ("System.String")
let corlibLocation = IO.GetDirectoryName (stringType.Assembly.Location)
let notMono = String.Format("Using non-Mono runtime engine: {0}", corlibLocation)

Target? Info <-
  fun _ ->
    if isMono then
      trace "Running on Mono"
    else
      trace notMono

Run? Info

The keyword let declares a F# variable, which is equivalent to property declarations used by NAnt and MSBuild. However, unlike those two tools, Fake allows the developer to invoke any .NET method, without security contraints.

As an experimental project, Fake does have some shortcomings. It does not execute its targets in parallel, although the code inside them can be easily parallelized. It also does not keep track of a target’s outputs up-to-date state, executing the target commands during every project rebuild, which makes it unsuitable for large projects. There is no support for using Fake under operating system other than Windows. And the F# language itself still remains exotic to most .NET developers, making the build scripts hard to understand and maintain.

Upgrading from CruiseControl.NET 1.5 to 1.6 / 1.7

2012-01-18T12:21:00.001-08:00

I've finally decided to update the version of CruiseControl.NET I use, going from 1.5 straight to 1.7 nightly build. My previous attempt ended with cryptic error messages, but, as this time the build server was already having some problems and required maintenance, I went through with the update (after fixing the problems first, of course).

Most important thing, if you don't already know it: there's a validator included in the downloadable package, which you can use to check how the server will interpret your pretty configuration files spaghetti. If you are making use of the pre-processor feature - the validator is indispensable. A neat trick while using it is copying the output (processed) configuration, changing the input files and copying the new output to a separate file, then running diff on those two to check whether the actual change you just introduced is what you were intending to do. In my case - I was checking whether I got exactly the same output while using a two-years-newer release by running my original configuration through the 1.5 validator and trying to get identical results from the 1.7 parser.
The initial result you'll get will most likely be this:

Unused node detected: xmlns:cb="urn:ccnet.config.builder"

Oh. Not good. StackOverflow has an answer that claims to fix this problem, only to result in this:

Unused node detected: xmlns="http://thoughtworks.org/ccnet/1/5"

Well - not exactly a change for the better. What is the problem? The changes in the configuration parser made it a bit more picky about the files it accepts. Now they have to start with the XML preamble and include the version information (1.5 or 1.6, there's no 1.7 schema yet). The required beginning of the main configuration file is now as follows:

<?xml version="1.0" encoding="utf-8"?>
<cruisecontrol xmlns:cb="urn:ccnet.config.builder"
xmlns="http://thoughtworks.org/ccnet/1/5">

Also, while 1.5 allowed you to include files containing a "naked" node (e.g. to reuse svn version control configuration), 1.6 requires the top level node in the included file to be either a <cb:config-template> or <cb:scope>. Thus, to be on the safe side, start each of your configuration sub-files with the following:

<?xml version="1.0" encoding="utf-8"?>
<cb:config-template xmlns:cb="urn:ccnet.config.builder"
xmlns="http://thoughtworks.org/ccnet/1/5">

With those changes in place, my configuration file results in the same pre-processor output both in CruiseControl.NET 1.5 and 1.7.

D'oh!

2009-05-08T08:24:00.006-07:00

I just spent two hours blaming CruiseControl.Net release candidate for a bug, which turned out to be a trailing \ in my configuration.

So remember, kids: nant -D:publishroot="E:\PublicBuilds\" publishbuild will invoke nant with the default target. To make it work as expected, one has to use nant -D:publishroot="E:\PublicBuilds\\" publishbuild.

Using a cellphone GPRS/EDGE/UMTS Internet connection through Bluetooth under Gentoo Linux

2008-08-25T03:44:00.006-07:00

Before you start, make sure that:

you can browse the Internet from your cellphone (take note of the connection profile you use)

you have a working Bluetooth connection between your phone and the PC

the devices are paired for connecting without asking for confirmation

you have bluez-utils emerged with USE="old-daemons"

Configure a RFCOMM connection with the phone:

in /etc/conf.d/bluetooth set RFCOMM_ENABLE=true

use sdptool search DUN to find the device's Bluetooth hardware address and the channel on which the cellphone listens for RFCOMM, the scan will take some time

in /etc/bluetooth/rfcomm.conf add a new connection with the address and channel you just found:


#
# RFCOMM configuration file.
#

rfcomm0 {
	# Automatically bind the device at startup
	bind yes;

	# Bluetooth address of the device
	device XX:XX:XX:XX:XX:XX;

	# RFCOMM channel for the connection
	channel	4;

	# Description of the connection
	comment "Cellphone GPRS/UMTS DUN";
}

execute /etc/init.d/bluetooth restart, you should now have a /dev/rfcomm0 device available, and cat /dev/rfcomm0 should cause the PC to connect to the cellphone (cat will output nothing, just kill it with Crtl+C when you verify the connection works).

Kernel requirements: besides what is needed for Bluetooth, enable all options under Device Drivers / Network device support / PPP (point-to-point protocol) support. This only adds 16KB to the kernel size. Recompile, install, reboot with your new kernel (or if you really don't want to reboot, compile PPP as a module and modprobe it).

Emerge ppp with USE="dhcp". Create a network service with ln -s /etc/init.d/net /etc/init.d/net.ppp0. Configure it by creating /etc/conf.d/net.ppp0 with the following contents:


### GPRS/EDGE/UMTS configuration ###
config_ppp0=( "ppp" )
link_ppp0="/dev/rfcomm0"

pppd_ppp0=(
	"noauth"
	"debug"
	"local"

	"defaultroute"
	"usepeerdns"

	"lcp-echo-interval 15"
	"lcp-echo-failure 3"

	"lock"

	"115200"
	"crtscts"
	)

chat_ppp0="
ABORT BUSY
ABORT ERROR
ABORT 'NO ANSWER'
ABORT 'NO CARRIER'
ABORT 'NO DIALTONE'
ABORT 'Invalid Login'
ABORT 'Login incorrect'
'' AT
TIMEOUT 5
OK 'ATH'
OK 'ATE1'
OK 'AT+CGDCONT=1,\"IP\",\"internet\"'
OK 'ATD*99#'
TIMEOUT 60
CONNECT ''
TIMEOUT 5
~--''
"
### end GPRS/EDGE/UMTS configuration ###

You'll need to replace "internet" with the name of the connection profile you use for your data transfer (this should be provided by your cellular operator - "internet" is what Plus GSM uses in Poland). Start the connection with /etc/init.d/net.ppp0 start and everything should work.

Software used:

sys-kernel/gentoo-sources-2.6.25-r7

sys-apps/openrc-0.2.5

sys-apps/baselayout-2.0.0

net-wireless/bluez-libs -3.36

net-wireless/bluez-utils-3.36 with USE="old-daemons"

net-dialup/ppp-2.4.4-r15 with USE="dhcp"

Hardware used:

Nokia N95 8GB

HP Pavilion built-in Bluetooth adapter

How-To based on articles:

Tom's attempts to get GPRS working over bluetooth with his laptop

Mobile Phone/UMTS - Gentoo Linux Wiki (extremely messy)

Jak połączyć się z internetem przez GPRS w linuksie?

fsck -y

2008-07-08T10:03:00.006-07:00

Wymiana procesora w laptopie

2008-07-06T09:24:00.006-07:00

Jakiś czas temu otwarcie obudowy laptopa było dla mnie przerażające - na pewno coś zepsuję, pogubię śrubki i nie będzie działać. Od pierwszego udokumentowanego podejścia minęło już nieco czasu, zdążyłem się oswoić i nabrać śmiałości. Fotorelacja z wczorajszej zabawy - wymiany procesora w laptopie HP Compaq - jest do obejrzenia dla ciekawskich, ja mam jeszcze parę dodatkowych wskazówek:

Rozkręcając laptopa/notebooka/inny mały komputer miej pod ręką pastę termoprzewodzącą i jakąś niekłaczącą szmatkę/chusteczki. Nawet jeśli planujesz tylko zajrzeć do środka - część elementów może wykorzystywać zewnętrzną obudowę w charakterze radiatora, pastę termoprzewodzącą trzeba zawsze wymienić (dokładnie usunąć starą, zaaplikować cienką warstwę świeżej) jeśli się rozdzieli posmarowane nią elementy.

Oznaczaj/zapisuj skąd wykręciłeś niestandardowe śrubki). Oszczędza to potem sporo kombinowania. ;-)

Większość śrub trzymających obudowę będzie wkręcana od spodu, ale część znajduje się zawsze z wierzchu, pod klawiaturą lub przyciskami multimedialnymi. Sprawdź czy płytka z tymi przyciskami nie jest przykręcona zanim zaczniesz ją podważać. :-)

Górna część laptopa (wyświetlacz i klawiatura) połączona jest z płytą główną kilkoma taśmami. Wyglądają one na strasznie delikatne i trudne do wpięcia, na szczęście tak nie jest. Wystarczy je odpiąć (zatrzask jest zazwyczaj od strony płyty głównej) i wyciągnąć.

Jeśli coś wymieniałeś - sprawdź, czy komputer nadal się uruchamia przed zmontowaniem go z powrotem. Zazwyczaj da się to zrobić nawet bez klawiatury, a można sobie oszczędzić sporo zbędnej pracy.

Przy okazji - mam na sprzedaż 2 kości RAM do laptopa (DDR 333Mhz 256MB CL2.5) oraz procesor Intel Celeron M 330 1.4GHz.

N-Gage po polsku

2008-07-05T13:20:00.006-07:00

Witamy w Chinach

2008-05-12T05:01:00.006-07:00

Właśnie zobaczyłem mało przyjazny komunikat:

This video is not available in your country.

Cholera. Od kiedy YouTube cenzuruje filmy? W tym przypadku ("Nowy Hymn Radia Maryja / Rammstein") na 100% nie chodzi o ochronę praw autorskich - przy takich zarzutach zdejmują film, a ten przez proxy z Wielkiej Brytanii można obejrzeć.

Cholerne tłumaczenia...

2008-05-06T09:11:00.006-07:00

Chyba czas odwołać się do mądrości kolektywu ;-) Mam problem ze znalezieniem dobrze brzmiących i jednoznaczych tłumaczeń dla "commit", "changeset" oraz "revision". Ma ktoś pomysły na sensowne tłumaczenia poniższych sformułowań? (teksty z polskiej wersji Redmine)

"The entry or revision was not found in the repository." (roboczo - "Obiekt lub wersja nie zostały znalezione w repozytorium.")

"Autofetch commits" (roboczo - "Automatyczne pobieranie zmian")

"Referencing keywords" (roboczo - "Słowa tworzące powiązania")

"Fixing keywords" (roboczo - "Słowa zmieniające status")

"revision, revisions, view revisions, latest revision" (roboczo - "wersja, wersje, pokaż wersje, najnowsza wersja" - jak to odróżnić od "version"?)

"Commits per month" (roboczo - "Zatwierdzenia według miesięcy")

"Commits per author" (roboczo - "Zatwierdzenia według autorów")

"Referencing and fixing issues in commit messages" (roboczo - "Odwołania do zagadnień w komentarzach zatwierdzeń")

"Associated revisions" (roboczo - "Skojarzone wersje")

"changeset, changesets" (roboczo - "zmiana, zmiany")

Pstrykanie

2008-04-13T08:51:00.006-07:00

Wywieszka w toalecie u mnie w pracy. Z kartką doklejoną poniżej oryginalnego apelu nie mam absolutnie nic wspólnego, to jakiś aspołeczny osobnik musiał dodać ;-)

Zabawa z bootchart

2008-03-27T14:02:00.006-07:00

Zainspirowany konkursem "kto szybciej" zacząłem kombinować z przyśpieszaniem startu mojego Gentoo. Udało mi się ściąć... 3 sekundy. Patentów wypróbowanych - całkiem sporo.

RC_PARALLEL_STARTUP="yes" - to są właśnie te uzyskane 3 sekundy (choć pamiętam, że z jakiegoś powodu, dawno temu, wyłączałem równoległe uruchamianie usług).

baselayout-2 - czas startu spadł o 30 sekund. Bardzo przyjemnie, choć wymagało ręcznego poprawiania błędów w skryptach startowych i nie potrafi wyłączyć komputera gdy ma problemy z odmontowaniem udziałów NFS (o dziwo, baselayout-1 zawsze sobie z tym radzi). Zrezygnowałem.

wyłączenie zbędnych usług - poleciało dhcp i distccd. Kolejne 10 sekund. Razem z poprawą z baselayout-2 miałoby to sens, ale samodzielnie - nie. Leniwy jestem, włączyłem z powrotem.

readahead-list - żadnej różnicy w mierzonym czasie, problemy z zależnościami pomiędzy skryptami w /etc/init.d/. Dziękuję.

squashfs + aufs - strasznie ryzykownie to wygląda, nie wypróbowałem.

"timeout 1" w grub.conf - bootchart tego nie mierzy, ale zawsze to nieco szybciej.

prelink - przy instalacji ebuild nie przechodzi własnych testów automatycznych. Nie.

LDFLAGS - pożyjemy, zobaczymy, ale tutaj raczej kolosalnej róznicy się nie spodziewam.

TuxOnIce, albo inaczej - hibernacja. Z nieznanych mi powodów czasem się nie wznawia. Jeśli się wznowi, to wyłącza monitor (EDIT: pomogło dodanie OnResume 99 /usr/bin/chvt 7 do /etc/hibernate/common.conf). Ale kiedy działa, to komputer startuje w 1/6 normalnego czasu. Nice. Przydało by się jakieś GUI.

Telefon. Z klapką.

2008-03-05T06:56:00.006-08:00

Szukam nowego telefonu. Na liście wymagań:

obudowa "z klapką"

odtwarzacz mp3(/wma/ogg)

slot kart pamięci albo przynajmniej 2GB wbudowanej

gniazdo USB i działanie jako urządzenie pamięci masowej

obsługa słuchawek stereo przez Bluetooth

dodatkowo punktowane gniazdo mini jack do słuchawek i marka Nokia

Ktoś zna takowe urządzenie?

Mój domowy serwer

2008-01-31T11:00:00.006-08:00

Jest mały, szarozielony i nazywa się snotling.

snotling ~ # cat /proc/cpuinfo
processor       : 0
vendor_id       : GenuineIntel
model name      : Pentium III (Katmai)
cpu MHz         : 448.646
flags           : fpu vme de pse tsc msr pae mce cx8 sep mtrr pge mca cmov pat pse36 mmx fxsr sse
bogomips        : 897.87
snotling ~ # uname -a
Linux snotling 2.6.23-gentoo-r6 #2 Thu Jan 31 13:14:15 CET 2008 i686 Pentium III (Katmai) GenuineIntel GNU/Linux

Dostała mu się jeszcze gigabitowa sieciówka, kontroler SATA, dysk 300GB i 512MB RAMu – ale to już inny paragon ;-) Tak wyglądał zaraz po przyniesieniu do domu:

A tak po dołożeniu ulepszeń:

gg.chrome.pl

2008-01-30T08:13:00.006-08:00

Korzysta ktoś może z transportu gg.chrome.pl? Jest jakiś powód, dla którego od wczoraj jestem bombardowany prośbami o autoryzację, których najwyraźniej nie da się zablokować?

It's not a bug, it's a feature

2008-01-23T10:49:00.006-08:00

Oj wybredny jest parser zapytań w MySQL, wybredny. SUM (a) w SELECT jak najbardziej przechodzi, ale w CREATE VIEW xxx AS SELECT już nie. Przy tworzeniu perspektywy baza odmawia współpracy komunikatem "funkcja nazwatabeli.SUM nie istnieje". Chodzi o to, że spacja pomiędzy SUM a nawiasem otwierającym jest inaczej interpretowana przy zwykłym zapytaniu a inaczej przy tworzeniu perspektywy - w pierwszym przypadku parser zaczyna od szukania funkcji nazwatabeli.SUM a gdy jej nie znajdzie wywołuje zwykłe SUM, w drugim przypadku od razu zgłasza błąd.

Sporo nerwów można stracić też przez inny "feature". MySQL w nazwach baz danych i tabel pozwala na znaki '_' i '-' oprócz zwykłych alfanumerycznych - ale takich tabel nie da się już użyć przy odwołaniu do kilku baz w jednym zapytaniu, bo parser ich po prostu nie znajdzie.

screen

2007-11-28T04:31:00.006-08:00

Bardzo, ale to bardzo przydatne polecenie:

ssh -t user@host screen -RD

Otwiera połączenie ssh z sesją screen'a, co pozwala wylogować się z maszyny host bez zamykania powłoki i kończenia uruchomionych poleceń. W celu zakończenia sesji ssh należy nacisnąć [crtl] + [a], [d], potem można powrócić do (działającej ciągle na serwerze) powłoki tym poleceniem co poprzednio. Żeby zamknąć sesję screen należy po prostu wydać polecenie exit.

Konwersja .mp3 na .amr

2007-11-01T17:13:00.006-07:00

Oczywiście wszystkie nowe komórki potrafią odtwarzać mp3. Tylko po co mi nowy telefon, jak stary nadal działa (i rozumie tylko dość egzotyczny format AMR)? Ku pamięci - konwersja plików dźwiękowych:

ffmpeg -i input.mp3 -acodec libamr_nb -ar 8000 -ab 12.2k -ac 1 output.amr

albo (ale to już mniej telefonów będzie potrafiło odtwarzać):

ffmpeg -i input.mp3 -acodec libamr_wb -ar 16000 -ab 23.85k -ac 1 output.amr

Oczywiście plik wejściowy może być w dowolnym formacie obslugiwanym przez ffmpeg, czyli prawie każdym istniejącym ;-) Pod Gentoo trzeba ustawić flagę USE="amr" przy emergowaniu ffmpeg żeby włączyć obsługę kodeka.

Kiepskie s-f

2007-10-16T06:33:00.006-07:00

"Dodatkowo kosmonauci odkryli, że jeden z nowych kabli jest o 40cm krótszy od tego, który miał zostać nim zastąpiony - nie sięga do złącza. Na szczęście po dokładnym obejrzeniu nie stwierdzili żadnych śladów korozji, więc wymiana nie była konieczna. Zainstalowali za to dodatkową osłonę termiczną wykonaną z zapasowego podręcznika obsługi oraz szarej taśmy samoprzylepnej. Na koniec usunęli założone wcześniej zworki obchodzące system bezpieczeństwa, upewnili się, że komputery działają i zamknęli obudowę." (tłumaczenie własne z języka angielskiego)

Pytanie warte piwa: z czego pochodzi cytat?

Twoja babcia na wybory zabiera koleżanki!

2007-10-08T15:15:00.006-07:00

Odebranie w Urzędzie Miasta zaświadczenia o prawie do głosowania poza miejscem zamieszkania : 24 minuty. Możliwość narzekania na rząd przez najbliższe cztery(*) lata : bezcenne.
(*) pełne cztery lata nie są gwarantowane

Tell us why you love Google Talk

2007-09-26T11:45:00.006-07:00

PicasaWeb Downloader

2007-08-20T15:22:00.006-07:00

Trochę ponad tydzień temu Walker chwalił się skryptem do uploadowania zdjęć do albumów PicasaWeb (program Picasa w wersji na linuksa nie posiada takiej funkcjonalności). Jego wpis przypomniał mi o leżącym odłogiem 1GB sieciowego miejsca, akurat gdy zastanawiałem się, jak przesłać przyjaciołom (aktualnie przebywającym w Norwegii) zdjęcia z wakacji. Do wgrania obrazów w końcu wykorzystałem Firefox Universal Uploader, został tylko jeden problem - jak pobrać taki album na dysk, nie instalując kobylastej Picasy?

Tomer Gabel napisał prosty konsolowy program w C#, który wykorzystuje Google Data API by zassysać całe albumy z PicasaWeb. Do wczoraj jego rozwiązanie miał jedną wadę - nie obsługiwało albumów prywatnych, wymagających znajomości klucza. Jednak Tomer uwzględnił liczne prośby użytkowników ;-) i uzupełnił brakującą funkcjonalność. PicasaWeb Downloader można pobrać z jego strony razem z kodem źródłowym w C#. Oczywiście, ponieważ to .Net, więc kompiluje się i działa również pod linuksem, przy użyciu Mono .

Zdjęcia panoramiczne

2007-08-01T10:10:00.006-07:00

W końcu znalazłem czas by wypróbować możliwości programu do składania zdjęć panoramicznych - hugin'a. Przy wsparciu dobrego tutoriala cały proces okazał się w miarę prosty (chociaż dość długotrwały - automat mielił zdjęcia ponad godzinę) a efekt końcowy jak dla mnie jest bardzo zadowalający.

data="http://backend.deviantart.com/embed/view.swf">

Na przyszłość muszę jeszcze pamiętać o takich "szczegółach" jak zablokowanie parametrów aparatu (czas naświetlania, przesłona itd.) po wykonaniu pierwszego zdjęcia z serii i zadbanie o wystarczającą ilość punktów odniesienia na zdjęciach (tzn. zdjęcia będące elementami panoramy powinny na siebie nachodzić w 30%-50% i zawierać obiekty charakterystyczne, szczególnie w pobliżu boków). Druga próba zrobienia zdjęcia panoramicznego właśnie dlatego niezbyt mi się udała. No i statyw by się przydał...

Debugging NUnit tests in Visual Studio 2005 Express

2007-07-02T09:00:00.006-07:00

VS2005 Express imposes many limitations on it's users as a trade-off for being free. It's main disadvantage IMHO is that it provides no support at all for unit tests. Fortunately there is a simple workaround for this. No, I am not talking about hacking VS to accept plugins as TestDriven.NET used to do. What I wanted to have was the ability to click "Debug" on a library project containing test and have it launched - inside the Visual Studio debugger.

This trick requires adding a tiny bit of magic code to the .csproj file:


<PropertyGroup>
  <Nunit_Path Condition="'$(NUNIT_PATH)' == ''">C:\Program Files\NUnit</Nunit_Path>
  <StartAction>Program</StartAction>
  <StartProgram>$(NUNIT_PATH)\bin\nunit.exe</StartProgram>
  <StartArguments>/run $(TargetFileName)</StartArguments>
  <!--.csproj.user overwrites those values!-->
</PropertyGroup>

This should be pasted at the end of the project file, after <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" /> and just before </Project>

Save the changes and open the project in Visual Studio. You can now launch the tests by clicking "Debug->Start Without Debugging" and debug them with "Debug->Start Debugging". One caveat, though - this assumes that NUnit is installed in C:\Program Files\NUnit. If your instalation directory is different, you have to set the environment variable NUNIT_PATH accordingly.

On a side note, some MSBuild/VS2005 quirks:

StartProgram has to point to an absolute location (i.e. not to a program in PATH)

StartWorkingDirectory has to be unset (or it could point to $TargetDir, if only I could get it to resolve instead of returning "@(_OutputPathItem->'%(FullPath)')" literally)

all those properties can be set from Professional version - Express does not show edit boxes for most of them

Krótkie lekcje

2007-06-26T11:00:00.006-07:00

Elektronika. Zasilacza 12V, 1000mA nie można zastąpić zasilaczem 12V, 1200mA mimo takich samych wtyczek. Próba kończy się głośnym pyknięciem i dymem unoszącym się z routera.

Marketing. Warto przyjmować reklamację produktu bez zbytniego wybrzydzania. Klient zapamięta miłą obsługę, a nie uszkodzony produkt i wróci po kolejne zakupy. Zwłaszcza, jeśli produkt został uszkodzony "tak nie do końca z winy sklepu".

hi5 - kolejny spammer

2007-06-05T08:59:00.006-07:00

Po niedawnej historii z automatycznym rozsyłaniem zaproszeń przez Netlog, ta sama taktyka stosowana jest przez stronę hi5. Zachęcam do przeczytania przestróg Piotra Koniecznego odnośnie poprzedniego przypadku.

Jeśli dałeś/aś się złapać, koniecznie zmień hasło do GMail'a. A na przyszłość pamiętaj, że regulamin google (i większości innych serwisów) zabrania ujawniania hasła.