Wstęp do programowania w Linuksie na przykładzie Ubuntu 53


Wstęp

W tym artykule chciałbym przybliżyć tematykę programowania pod Ubuntu (i ogólnie pod Linuksem). Artykuł nie jest w żaden sposób wyczerpujący, raczej ma za zadanie nakreślić całościowy obraz omawianej tematyki. Informacje tutaj zawarte powinny mieć zastosowanie w dowolnej dystrybucji Linuksa, jedynie nazwy pakietów są specyficzne dla Debiana/Ubuntu.

Zaczynamy!

Pierwszą rzeczą, którą powinno się wykonać chcąc zabrać się za programowanie, jest zainstalowanie pakietu build-essential:
sudo apt-get install build-essential

Pakiet ten zawiera najpotrzebniejsze rzeczy, takie jak kompilator C, program make, pliki nagłówkowe biblioteki standardowej języka C, słowem jest niezbędny do programowania systemowego jak i kompilacji programów ze źródeł.

Języki programowania

Jedna uwaga na początek, przez kompilator rozumiem program, który tłumaczy kod źródłowy na kod maszynowy, nie środowisko programistyczne. O środowiskach programistycznych będzie dalej.

C

W światku uniksowym język C ma wciąż bardzo duże zastosowanie, większość Unix-ów i systemów uniksopodobnych jest napisana w całości w C. Także duża część oprogramowania użytkowego dla tych systemów jest tworzona w tym języku. Do programowania w C potrzebujemy kompilatora. Najpopularniejszym jest gcc, który instaluje się razem z paczką build-essential, o czym pisałem wcześniej. Spośród innych kompilatorów, można też zainteresować się tcc (w pakiecie o tej samej nazwie), który cechuje się bardzo dużą szybkością działania oraz Intel C Compiler (icc, w repozytoriach brak), który ponoć bardzo dobrze optymalizuje kod pod procesory Intela (w sumie nie ma się czemu dziwić;)). W dalszej części skupię się na gcc.

Chcąc skompilować przykładowy program:

#include <stdio.h>

int main (int argc, char *argv[])
{
	printf ("Hello World!\n");
	return 0;
}

trzeba się posłużyć poleceniem:gcc hello.c -o hello
Należy pamiętać o fladze -o, po której podaje się nazwę pliku wynikowego, gdyż w przeciwnym razie wynikowy program umieszczony zostanie w pliku a.out. Warto też pamiętać, że w Linuksie pliki wykonywalne nie muszą mieć rozszerzenia. Chcąc skompilować program składający się z kilku plików źródłowych można albo podać wszystkie w linii polecenia podanej powyżej, albo (lepiej), skompilować każdy plik osobno, a następnie skonsolidować całość:
gcc -c hello.c -o hello.o
gcc -c world.c -o world.o
...
gcc -c utils.c -o utils.o
gcc -o hello hello.o world.o ... utils.o

To podejście ma taką zaletę, że po zmianie jednego pliku nie trzeba przekompilowywać wszystkich pozostałych plików.

Korzystając z gcc, warto zawsze stosować flagę -Wall, która powoduje wypisywanie większej ilości ostrzeżeń przy kompilacji – co bardzo pomaga przy szukaniu błędów.

Dla chcących tworzyć też pliki wykonywalne dla systemu MS Windows dodam, że w repozytoriach w pakiecie mingw32 znajduje się gcc kompilujący pliki do formatu PE stosowanego w środowisku Win32. Korzysta się z tego pakietu tak jak ze zwykłego gcc, trzeba tylko dodać na początku i586-mingw32msvc- (np. i586-mingw32msvc-gcc).

C++

Język C++ został zaprojektowany przez Bjarne’a Stroustrupa jako następca C, rozbudowany głównie o obiektowość. W latach 90 zyskał dużą popularność zarówno w programowaniu systemowym jak i użytkowym.

Głównym narzędziem przeznaczonym do pracy z C++ jest g++, czyli kompilator języka C++ wchodzącego w skład zestawu kompilatorów GNU (ang. GNU Compilers Collection). Z programu korzysta się bardzo podobnie jak z gcc, pamiętając tylko o tym, żeby używać polecenia g++ w miejsce gcc. Częstym błędem jest korzystanie z gcc do kompilacji kodu C++.

Podsumowując, mając kod hello.cpp:

#include <iostream>

using namespace std;

int main (int argc, char *argv[])
{
        cout << "Hello World!" << endl;
        return 0;
}

używamyg++ -Wall -o hello hello.cpp

Pascal

Pascal jest wysokopoziomowym proceduralnym językiem programowania, stworzonym przez Niklausa Wirtha głównie z myślą o nauce programowania. Z tego powodu do dzisiaj jest często wykorzystywany na uniwersytetach. W latach 80 zdobył dużą popularność, głównie za sprawą środowiska Borland Turbo Pascal. Wbrew obiegowej opinii, większość dialektów Pascala wspiera „nowinki” w stylu programowania obiektowego i tym podobnych.

Pod Linuksem mamy do wyboru dwa kompilatory: Free Pascal i gpc. Free Pascal jest wieloplatformowym, samodzielnym kompilatorem. Jest w dużym stopniu zgodnym z Turbo Pascal, jak i innymi odmianami jak Object Pascal, czy nawet częściowo Delphi. Zawiera większość modułów znanych z TP, takich jak CRT. Kompilator znajduje się w repozytoriach w pakiecie fp-compiler. Przykładowy program:

program Hello;

begin
        writeln ('Hello World!')
end.

kompilujemy poleceniem:
fpc hello.pas
Można zauważyć, że kompilator działa bardzo szybko 😉 Dodam jeszcze, że w pakiecie fp-ide znajduje się środowisko wzorowane na produkcie Borlandu.

Drugim kompilatorem jest gpc, będącym częścią gcc (pojmowanego jako zestaw kompilatorów), przez co oferuje te same możliwości. Jak nietrudno zgadnąć, znajduje się w pakiecie gpc.

Java

Java jest stworzonym przez firmę Sun językiem programowania zorientowanym na programowanie obiektowe, mającym na celu maksymalizację efektywności tworzenia oprogramowania. Składniowo jest wzorowany na C++. W ostatnich latach język ten stał się bardzo popularny. Kod źródłowy w języku Java nie jest kompilowany do kodu maszynowego danej platformy, tylko do specjalnej reprezentacji pośredniej (tzw. bajtkodu), który następnie jest wykonywany na maszynie wirtualnej Javy. Dzięki temu, raz skompilowany program w Javie można uruchomić na dowolnej platformie sprzętowo/programowej posiadającej maszynę wirtualną.

Chcąc zacząć przygodę z Javą, trzeba zaopatrzyć się w Java Development Kit, najlepiej w wersji pochodzącej od Suna. Znajduje się on w pakiecie sun-java5-jdk lub sun-java6-jdk, w zależności od wersji. Można mieć zainstalowanych równolegle kilka wersji tak maszyny wirtualnej, jak i JDK i wtyczki do przeglądarki, dlatego warto użyć programu update-alternatives aby ustawić domyślną implementację.

Przykładowy program:

public class hello
{
        public static void main (String [] args)
        {
                System.out.println ("Hello World!");
        }
}

kompilujemy poleceniem javac hello.java Otrzymamy plik hello.class, zawierający skompilowaną do bajtkodu klasę hello. Program uruchamiamy poleceniem:java helloTrzeba pamiętać, że jako argument podajemy nazwę klasy a nie plik zawierający tą klasę.

Z innych implementacji wymienię tylko gcj, będący częścią gcc, który potrafi kompilować kod w Javie także do natywnego kodu maszynowego.

.NET/C#

Środowisko .NET jest odpowiedzią firmy Microsoft na Javę. Ma wiele cech wspólnych, m.in. użycie bajtkodu i maszyny wirtualnej, przez co programy .NET, przynajmniej w teorii, są niezależne od platformy, na której zostały skompilowane. W przeciwieństwie do Javy, środowisko .NET nie wymaga pisania kodu w jednym języku, można wybrać jeden z wielu, ale najbardziej popularnym jest chyba C#. Twórcą tego języka jest Anders Hejlsberg, który odpowiada także za środowisko Delphi. Składnia C# jest dosyć podobna do Javy. Drobna dygresja. Niektórzy mówią na C# siszarp, ja postuluję mówić po polsku cis (wymawiane prze c, nie ć jak gatunek drzewa), gdyż w muzyce # (ang. sharp) oznacza podniesienie dźwięku o pół tonu, a dźwięk pół tonu wyższy od C to właśnie cis;)

Co prawda Microsoft udostępnia swoje oprogramowanie wyłącznie na system MS Windows (chociaż istnieje implementacja Rotor działająca pod OSX i FreeBSD, ale ma szereg ograniczeń licencyjnych), firma Novell stworzyła własną, otwartą implementację, dzięki czemu można korzystać z .NET także pod Linuksem. Implementacją tą jest mono. Samo środowisko uruchomieniowe znajduje się w pakiecie mono, który powinien być zainstalowany wraz z systemem. Potrzebny jest jeszcze kompilator C#. Znajduje się w pakietach mono-mcs i mono-gmcs, które różnią się tym, że mcs wspiera .NET w wersji 1.1 a gmcs w wersji 2.0. Dalej skupię się na gmcs. Dobrze jest też mieć pakiet mono-devel. Przykładowy program:

using System;

public class hello
{
        public static void Main (string [] args)
        {
                Console.WriteLine ("Hello World!");
        }
}

kompilujemy poleceniem:
gmcs hello.cs
W wyniku otrzymamy plik hello.exe (też mi się to rozszerzenie nie podoba), który wykonujemy wpisując
mono hello.exe
albo prościej:
./hello.exe
Druga metoda działa jeśli mamy wsparcie dla binfmt_misc (w Ubuntu jest chyba domyślnie), natomiast pierwsza, choć dłuższa, ma tę zaletę, że działa zawsze.

Dużo dodatkowych bibliotek dla Mono można znaleźć w repozytoriach w pakietach o nazwach kończących się na -cil (np. libgtk2.0-cil, czy libmono-winforms2.0-cil).

Drugą implementacją środowiska .NET jest dotgnu PortableNet, znajdujące się w pakiecie pnet, jednak nigdy z tego nie korzystałem, a nie chcę pisać o czymś, na czym się nie znam 😉

Języki skryptowe

Tyle jeśli chodzi o języki kompilowane, przejdźmy do języków skryptowych. Programy napisane w językach skryptowych przy każdym uruchomieniu są interpretowane z postaci źródłowej, przez co nie ma fazy kompilacji, natomiast z drugiej strony, do działania wymagają zainstalowanego odpowiedniego interpretera.

Bash

Bash jest domyślnym interpreterem poleceń w Ubuntu, może też służyć do pisania skryptów. Takie skrypty najczęściej wspomagają administrację systemem, pozwalając na automatyzację niektórych czynności. Przykładowy skrypt w Bashu:

#!/bin/bash

echo "Hello World"

Pierwszy wiersz mówi systemowi, jakiego interpretera należy użyć do wykonania skryptu – w tym przypadku jest to bash. Skrypt można uruchomić albo jawnie wywołując interpreter:
bash hello.sh
albo po prostu skorzystać z informacji zawartej w skrypcie. Trzeba tylko najpierw nadać bit wykonywalności skryptowi, który mówi systemowi, że plik zawiera program, który można wykonać
chmod a+x hello.sh
./hello.sh

Pisanie w Bashu jest bardzo proste – umieszczamy w skrypcie polecenia, które normalnie wpisalibyśmy do konsoli. I tak np. chcąc skopiować kilka plików do katalogu, spakować katalog, a następnie go usunąć, można utworzyć skrypt, który będzie to robił za nas:

#!/bin/bash

mkdir -p kopia
cp wazne.txt kluczowe.jpg niezastapione.pdf kopia
tar cjf kopia.tar.bz2 kopia
rm -rf kopia

Więcej info:man bash

Perl

Perl jest językiem skryptowym stworzonym przez Larry’ego Walla do usprawnienia pracy administratora. Wbudowana obsługa wyrażeń regularnych czyni go idealnym narzędziem do obróbki danych tekstowych. Składnia czerpie z takich języków ja Bash, C, sed czy awk.

Interpreter znajdziemy w pakiecie perl, który, najpewniej, już się znajduje w systemie. Przykładowy skrypt:

#!/usr/bin/perl -w

use strict;

print "Hello World\n;

Podobnie jak w przypadku Basha, pierwszy wiersz zawiera nazwę interpretera. Nawiasem mówiąc, warto podać flagę -w interpreterowi, jak również dyrektywę use strict;, które ułatwiają znacząco szukanie błędów w programach. Program uruchamiamy podobnie jak w przypadku Basha: nadajemy bit wykonywalności, a następnie:
./hello.pl

Dodatkowe biblioteki Perla, zwane tutaj „modułami”, można instalować albo „normalnie” z repozytoriów, albo za pomocą programu cpan, będącego odpowiednikiem apt-get dla modułów perlowych.

Dużo dokumentacji do Perla można znaleźć w podręczniku systemowym, strona perl zawiera spis wszystkich stron wraz z krótkim opisem:
man perl

PHP

PHP jest językiem, wzorowanym na Perlu, stosowanym głównie do programowania serwisów internetowych. Do zalet należy prostota języka, powszechność instalacji (dzięki czemu banalnie łatwo znaleźć hosting oferujący PHP), oraz duża ilość bibliotek. Do wad można zaliczyć pewną, hmmm, toporność tego języka.

Chcąc korzystać z PHP pod Linuksem można zainstalować moduł serwera Apache obsługujący PHP (w pakiecie libapache2-mod-php5), lub PHP jako moduł CGI (pakiet php5-cgi, który pracuje z każdym serwerem obsługującym CGI). Mimo, iż głównie stosuje się PHP jako język do pisania skryptów na serwerze WWW, można go też wykorzystać do pisania „zwykłych” skryptów. Trzeba wtedy zainstalować pakiet php5-cli. Tym sposobem, przykładowy program:

#!/usr/bin/php
<?php

echo "Hello World!\n";

?>

po nadaniu bitu wykonywalności, uruchamiamy standardowo:./hello.php

Python

O Pythonie wiem niewiele. Jedną z ciekawych cech jest to, że bloki instrukcji są zaznaczane wyłącznie za pomocą wcięć, a nie ograniczników takich jak { } stosowanych w innych językach. W każdym razie, interpreter znajdziemy w pakiecie python, który powinien być standardowo zainstalowany. Przykładowy program: hello.py

#!/usr/bin/python

print "Hello World!"

Ruby

Ruby jest ostatnim krzykiem mody w dziedzinie języków programowania, głównie za sprawą środowiska Ruby on Rails, służącego do szybkiego tworzenia aplikacji internetowych. Twórcą języka jest Yukihiro „Matz” Matsumoto.

Do korzystania z Ruby wystarczy zainstalować pakiet ruby, zawierający interpreter ruby. Przykładowy program: hello.rb

#!/usr/bin/ruby

puts "Hello World!"

Edytory i środowiska programistyczne

Co prawda prawdziwi programiści programy piszą poleceniem cat przekierowanym do pliku, ale zanim osiągnie się taki poziom, często wygodniej jest skorzystać z wyspecjalizowanego edytora tekstu czy wręcz zintegrowanego środowiska programistycznego.

Edytory tekstu

Do prostych zadań wystarczy „zwykły” edytor tekstu z podświetlaniem składni. Edytory tekstu dołączone do środowisk GNOME (gedit) czy KDE (kate) oferują przyzwoity zestaw funkcji takich jak podświetlanie składni, automatyczne tworzenie wcięć w kodzie, wyszukiwanie i zamiana z użyciem wyrażeń regularnych, możliwość edycji wielu plików w kartach. Oba programy można też rozszerzać za pomocą wtyczek.

Wyższą szkołą jazdy są edytory vim i Emacs, nad którymi jednak nie będę się rozpisywał, gdyż wystarczająco dużo materiałów można znaleźć w Internecie.

Anjuta

Anjuta jest zintegrowanym środowiskiem graficznym dla środowiska GNOME. Anjuta oferuje wszystko czego można oczekiwać od środowiska programistycznego – zarządzanie projektami, integracja z debuggerem, systemami kontroli wersji czy też programem glade, służącym do wizualnego projektowania interfejsów użytkownika GTK+.

Strona domowa projektu. Anjuta jest w repozytoriach Ubuntu w pakiecie anjuta.

Code::Blocks

Code::Blocks jest wieloplatformowym środowiskiem programistycznym stworzonym głownie do programowania w C/C++.

Strona domowa projektu. Niestety, programu nie ma w oficjalnych repozytoriach Ubuntu, tak więc trzeba go ściągnąć i zainstalować samemu.

Eclipse

Eclipse to prawdziwy kombajn programistyczny, stworzony przez firmę IBM. Oryginalnie stworzony do programowania w Javie, istnieją wtyczki rozszerzające możliwości środowiska o kolejne języki, jak np. wtyczka CDT dla języka C. Wadą programu jest duże zapotrzebowanie na zasoby systemowe.

Strona domowa projektu. Eclipse znaleźć można w repozytoriach w pakiecie eclipse.

Gambas

Gambas jest środowiskiem do szybkiego tworzenia aplikacji w języku Visual Basic. Posiada narzędzie do tworzenia GUI i obsługi baz danych.

Strona domowa projektu. Program znajduje się w pakiecie gambas.

Geany

Geany jest prostym środowiskiem programistycznym, nie oferującym wielu zaawansowanych funkcji, za to skupiającym się na prostocie.

Strona domowa projektu. Program znajduje się w pakiecie geany.

KDevelop

KDevelop jest środowiskiem programistycznym stworzonym dla KDE. Posiada narzędzie do projektowania interfejsów Qt, uzupełnianie składni, integruje się z debuggerem czy systemami kontroli wersji.

Strona domowa projektu. Program znajduje się w pakiecie kdevelop.

Lazarus

Lazarus to IDE to tworzenia aplikacji w języku Pascal, luźno wzorowane na Delphi.

Strona domowa projektu. Program znajduje się w pakiecie lazarus (gutsy wzwyż).

MonoDevelop

MonoDevelop jest środowiskiem przeznaczonym głównie do pisania aplikacji .NET/Mono w języku C#, chociaż w ostatnich wydaniach dodana została obsługa języków C i C++. Program posiada narzędzie do projektowania GUI z użyciem biblioteki GTK#, obsługę projektów (w tym tych z Visual Studio 2005), podpowiadanie składni, wbudowaną przeglądarkę dokumentacji. Do wad należy zaliczyć dużą niestabilność programu, choć ta poprawia się z wydania na wydanie; oraz brak debuggera. W każdym razie polecam do C#.

Strona domowa projektu. Program znajduje się w pakiecie monodevelop, choć ze względu na duże tempo rozwoju programu, warto zainstalować najnowsze stabilne wydanie, którego może nie być jeszcze w repozytoriach.

NetBeans

NetBeans jest środowiskiem programistycznym stworzonym przez firmę Sun, przeznaczonym pierwotnie dla Javy, które z czasem dorobiło się rozszerzeń dla innych języków jak C, C++ czy Ruby. Posiada wiele kreatorów dla Javy, pozwalając szybko rozpoczynać różne typy projektów. Do wad można zaliczyć dziwny wygląd („dzięki” bibliotece Swing), oraz stosunkowo duże zapotrzebowanie na zasoby (choć moim zdaniem mniejsze niż Eclipse). Polecam głównie do Javy.

Strona domowa projektu. Program znajduje się w pakiecie netbeans (może być nienajnowsza wersja).

XDevelop

XDevelop jest komercyjnym, wieloplatformowym środowiskiem programistycznym.

Strona domowa projektu. Programu nie ma w repozytoriach. Ukierunkowany głównie na C# i Javę, oferuje chyba wszystko, czego można chcieć od IDE.

Projektowanie stron internetowych

W repozytoriach Ubuntu znajdziemy też trzy aplikacje ukierunkowane na tworzenie stron internetowych:
Bluefish, Quanta Plus oraz Screem.

Biblioteki

Biblioteki stanowią zbiór kodu gotowego do użycia przez aplikacje.

Przy kompilowaniu programów korzystających z bibliotek, trzeba pamiętać, że przeważnie trzeba mieć zainstalowane, poza samymi bibliotekami, także pakiety z plikami nagłówkowymi, bibliotekami statycznymi, etc. Takie pakiety mają zwykle taką samą nazwę co pakiety z właściwą biblioteką z dodatkowym przyrostkiem -dev. Tak więc chcąc np. użyć w programie biblioteki libjpeg, poza pakietem libjpeg62 potrzeba pakietu libjpeg62-dev.

Drugą rzeczą, to poza załączeniem odpowiednich plików nagłówkowych w źródłach, trzeba też podać odpowiednie flagi dla linkera, żeby ten mógł skonsolidować wyjściowy program z odpowiednimi bibliotekami. W przypadku gcc, tą flagą jest -lnazwabiblioteki, tak więc dla podanej wyżej biblioteki libjpeg kompilacja przykładowego programu będzie wyglądała:gcc -Wall -o test test.c -ljpegOdnośnie linkowania bibliotek: gcc nie linkuje standardowo biblioteki matematycznej. Jeśli się korzysta z funkcji takich jak sin(), exp() czy innych zadeklarowanych w nagłówku math.h, trzeba explicite podać flagę -lm.

Przydatnym narzędziem jest program pkg-config, podający potrzebne flagi, które należy przekazać programowi. Użycie programu jest proste:
pkg-config --cflags biblioteka
pkg-config --libs biblioteka

Pierwsze wywołanie zwraca flagi dla kompilatora, drugie flagi dla linkera. Wywołania można połączyć, jak również użyć w bashu operatora `, który wstawi wynik jednego polecenia do drugiego polecenia:
gcc -Wall `pkg-config --cflags --libs gtk+-2.0` -o hellogtk hellogtk.c

Aha, jeszcze jedna uwaga na koniec. Jak nietrudno się domyślić, nie ma tutaj ani WinAPI, ani MFC, ani pliku nagłówkowego windows.h, tak więc nawet nie próbujcie z tego korzystać 😉

Programowanie systemowe

Linux jest w dużej mierze zgodny (a w każdym razie stara się, z różnym skutkiem) być zgodny z normami POSIX, dzięki czemu można korzystać z interfejsów znanych z innych Unix-ów. Tak więc, do obsługi wejścia/wyjścia oraz podstawowej funkcjonalności języka C mamy bibliotekę standardową języka C (libc), do obsługi sieci mamy BSD sockets, do komunikacji między procesami mamy mechanizmy IPC System V, do wątków służy biblioteka Pthreads.

Graficzny interfejs użytkownika

W odróżnieniu od innych systemów operacyjnych w Linuksie nie ma jednej biblioteki do obsługi graficznego interfejsu użytkownika. Podstawą jest system X Window, oferujący podstawową funkcjonalność, taką jak okna, obsługa zdarzeń, nie zawiera zaś żadnych kontrolek (widgetów) takich jak przyciski, czy pola tekstowe. Tą funkcjonalność dostarczają dodatkowe biblioteki, zbudowane na wierzchu X. Przez długi czas de facto standardem była biblioteka Motif, natomiast obecnie najpopularniejszymi w środowisku Linuksowym są GTK+, Qt oraz wxWidgets. Z mniej popularnych istnieją Tk, FLTK oraz Fox Toolkit, których nie będę tu opisywał.

GTK+

GTK+ jest napisaną w języku C biblioteką do tworzenia graficznego interfejsu użytkownika. Na tej bibliotece opierają się środowiska Gnome i XFCE. Mimo, że napisana w C, zaprojektowana jest w pełni obiektowo. Oferuje też wiązania (ang. bindings) dla wielu języków programowania: oficjalnie wspierane są C++, C#, Java, Perl i Python. Biblioteka dostępna jest na wszystkie ważniejsze platformy, choć aplikacje GTK+ pod systemami Windows i OSX wyglądają trochę „obco”. Do tworzenia interfejsów można wykorzystać program Glade, którego pliki mogą być ładowane w czasie wykonania programu za pomocą biblioteki libglade.

W skład biblioteki wchodzi kilka mniejszych bibliotek, w tym biblioteka GLib, zawierająca niezwiązaną z graficznym interfejsem funkcjonalność, taką jak struktury danych, obsługa wątków i plików, ułatwiając programowanie w C, jak też zwiększając przenośność kodu.

Biblioteka GTK+ jest licencjonowana na warunkach licencji LGPL. Wszystko, co potrzeba do kompilowania programów korzystających z biblioteki GTK+ znajduje się w pakiecie libgtk2.0-dev.

Qt

Qt jest wieloplatformową biblioteką do tworzenia interfejsów użytkownika napisaną w języku C++, stworzoną przez firmę Trolltech. Qt jest podstawą środowiska KDE. Oprócz języka C++, można korzystać z innych języków, w tym Javy, Pythona i Ruby. Wraz z biblioteką dostępny jest program QtDesigner do łatwego projektowania okien.

Oprócz klas służących do tworzenia okien, Qt zawiera też szereg pomocniczych klas do obsługi XML, baz danych, I/O, wątków i podobnych, pozwalających na pisanie przenośnych programów.

Biblioteka Qt jest dostępna na jednej z 3 licencji: GPL, QPL oraz komercyjnej. Całość w pakiecie libqt4-dev.

wxWidgets

wxWidgets jest wieloplatformową biblioteką do tworzenia GUI, stworzoną w języku C++. Biblioteka wxWidgets cechuje się tym, że sama nie rysuje widgetów, tylko korzysta z biblioteki dostępnej na danej platformie – w przypadku Linuksa jest to GTK+. Poza C++, z biblioteki można korzystać w różnych językach programowania, w tym Javie, Perlu i Pythonie. Biblioteka zawiera też użytkowe, niewizualne klasy pomocne przy tworzeniu wieloplatformowych aplikacji.

Biblioteka wxWidgets jest dostępna na własnej licencji, wxWindows Library Licence, podobnej do LGPL. Do korzystania z biblioteki potrzebny jest pakiet libwxgtk2.6-dev bądź libwxgtk2.8-dev

Grafika i multimedia

SDL

SDL (Simple Directmedia Layer) jest wieloplatformową (Linux/Unix/Windows/OSX/inne), napisaną w języku C biblioteką do obsługi multimediów, z naciskiem na gry. Sama biblioteka jest dosyć niskiego poziomu, zawiera bardzo podstawową funkcjonalność, jak obsługa urządzeń takich jak ekran czy karta dźwiękowa, blitting (kopiowanie i składanie prostokątnych obszarów obrazu), czy ręczne manipulowanie tablicy pikseli. Nie zawiera za to np. funkcji rysujących prymitywy graficzne takie jak trójkąty; czy też dekodowania dźwięku w różnych formatach. Taką funkcjonalność można uzyskać za pomocą dodatkowych bibliotek, których jest dostępnych dosyć sporo.

SDL wspiera natywnie OpenGL, przez co można ją uznać za pewien odpowiednik biblioteki DirectX dostępnej dla systemów z rodziny MS Windows. Dostępna jest na licencji LGPL, a znaleźć ją można w pakiecie libsdl1.2-dev.

Allegro

Alternatywą dla biblioteki SDL jest biblioteka Allegro, oferująca podobne funkcje. Nigdy nie używałem tej biblioteki, więc nie jestem w stanie wiele napisać, ale postanowiłem ją tutaj zamieścić, w nadziei, że komuś się przyda;-)

Licencja: LGPL. Pakiet: liballegro4.2-dev.

OpenGL

Biblioteka OpenGL, stworzona przez firmę SGI jest de facto standardem jeśli chodzi o grafikę trójwymiarową. Przeważnie instaując sterowniki do karty graficznej instaluje się potrzebne biblioteki. Można też skorzystać z biblioteki Mesa, będącej progrmową implementacją API OpenGL. Trzeba jednak pamiętać, że oferuje słabszą wydajność w porównaniu z implementacjami sprzętowymi.

Warto zauważyć, że samo API OpenGL definiuje jedynie funkcje tworzące grafikę, nie zawiera żadnych funkcji tworzących okna, czy obsługujących zdarzenia pochodząca z klawiatury czy myszki. Dlatego trzeba skorzystać z dodatkowcyh bibliotek, które realizują te funkcje. Mogą to być biblioteki obsługujące GUI, takie jak GTK+ (biblioteka GtkGlExt) czy Qt; lub też wyspecjalizowane biblioteki do obsługi grafiki takie jak SDL, czy biblioteka GLUT, będącą rozszerzeniem OpenGL o obsługę okien, prostego interfejsu użytkownika, czy zdarzeń pochodzących od użytkownika.

OpenGL jest wieloplatformowe, dostępne na wszystkie platformy komputerowe i większość konsol (poza XboX).

Dokumentacja

Jak wszyscy dobrze wiedzą, najlepszym źródłem wszelakiej informacji jest Google, lecz czasami warto sięgnąć w bardziej wyspecjalizowane źródła. W przypadku systemów wzorowanych na Unix, takim źródłem jest podręcznik systemowy. Wystarczy wpisać w terminaluman tematlub opcjonalnieman rozdział temata otrzymamy stronę poświęconą danemu zagadnieniu. Podręcznik podzielony jest na następujące sekcje [rozdziały]:

  1. Polecenia konsoli i programy użytkowe (czyli wszystko to, co da się wpisać w shellu)
  2. Wywołania systemowe (czyli funkcje dostarczane przez kernel)
  3. Funkcje biblioteczne (czyli funkcje dostarczane przez dodatkowe biblioteki)
  4. Specjalne pliki (zwykle umiejscowione w katalogu /dev)
  5. Formaty plików (np. /etc/passwd)
  6. Gry
  7. Różne
  8. Polecenia administracyjne

Zajmując się programowaniem, warto jest zainstalować pakiet manpages-dev, który zawiera strony podręcznika poświęcone wywołaniom systemowym oraz podstawowym funkcjom bibliotecznym. Mając zainstalowany ten pakiet, można szybko uzyskać informacje o interesujących nas funkcjach:man 2 open
man 3 strcmp
Często też pakiety -dev zawierają strony podręcznika, tak więc chcąc poczytać np. o funkcji curl_easy_setopt biblioteki libcurl wystarczy wpisać man curl_easy_setopt
Podobnym mechanizmem do man jest info. Dla przykładu wpisując info ipc można poczytać o mechanizmach IPC dostępnych w systemie. Dla nielubiących konsoli dodam, że przeglądarka pomocy GNOME (yelp) potrafi czytać strony tak man jak i info – wystarczy w pasku adresu tego programu wpisać man:strcmp czy info:ipc.

Dokumentację często można znaleźć w pakietach -doc. Warto się zapoznać z katalogiem /usr/share/doc, gdzie można znaleźć wiele interesujących programistę informacji.

Oprócz tego w repozytoriach można znaleźć dwa programy – przeglądarki dokumentacji – devhelp, zawierający głównie materiały o programowaniu w środowisku GNOME, oraz monodoc dotyczący Mono, otwartej implementacji .NET.

Narzędzia

make – narzędzie do budowania aplikacji.

Ręczne wpisywanie poleceń wywołujących kompilator może być bardzo męczącą czynnością. Na szczęście istnieją narzędzia, które pomagają w budowaniu programów. W systemach uniksowych taką rolę pełni program make. Make używa skryptów, zwanych Makefile opisujących proces budowania aplikacji. Przykładowy skrypt:

CC=gcc
CFLAGS=-O3 -Wall
LIBS=-Wall -lm

SOURCES=
	gfx.c 
	main.c 
	menu.c 

HEADERS=
	gfx.h 
	menu.h


OBJS=$(SOURCES:.c=.o)

all: myapp

.c.o:
	$(CC) -c $(CFLAGS) $< -o $@

$(OBJS): $(HEADERS)

myapp: $(OBJS)
	$(CC) -c $(CFLAGS) $< -o $@

Skrypt ten kompiluje program złożony z pięciu plików. Co więcej, pilnuje też zależności między plikami w prosty sposób. Pierwsze wiersze deklarują zmienne, odpowiednio kompilator, flagi kompilatora, flagi linkera, pliki ze źródłami, pliki nagłówkowe. Można je dowolnie edytować. Kolejny definiuje zmienną OBJS, powstałą ze zmiennej SOURCES.

Następne wiersze opisują reguły budowania poszczególnych obiektów. Reguły mają ogólną postać:

cel: zależności
	instrukcje budowania celu

Cel jest nazwą obiektu, zwykle pliku, którego dotyczy reguła. Zależności to nazwy celów, które muszą być zbudowane przed budowaniem właściwego celu. Oznacza to też, że w przypadku zmiany jakiegoś pliku, należy przekompilować wszystkie cele, które zależą od tego pliku. W następnych wierszach następuje dowolna ilość instrukcji, które mają prowadzić do zbudowania docelowego obiektu. Należy zwrócić uwagę, że instrukcje muszą być wcięte znakiem tabulacji.

Wiersz all: myapp definiuje pierwszy cel. Jeżeli uruchomi się program make bez żadnych argumentów, wykona pierwszy cel wymieniony w pliku Makefile. Wiersz .c.o:mówi jak z pliku .c otrzymać plik .o. Wiersz $(OBJS): $(HEADERS) mówi, że pliki obiektowe zależą od wszystkich nagłówków – w ten sposób zmiana pliku nagłówkowego spowoduje konieczność przekompilowania także plików obiektowych. Jest to prosty sposób dbania o zależności między plikami źródłowymi. Alternatywnie, można określić jawnie zależności każdego pliku źródłowego. Ostatni wiersz instruuje program make jak zbudować wynikowy plik wykonywalny.

Acha, program make uruchamiamy po prostu:make

gdb – debugger systemu GNU

Debugger jest narzędziem pozwalającym na śledzenie wykonania programu, „podglądanie” wartości zmiennych i, ogólnie, ułatwiającym szukanie błędów w oprogramowaniu, stąd też nazwa. W Linuksie mamy do dyspozycji program gdb, czyli debugger systemu GNU. Wiele środowisk programistycznych integruje się z gdb, oferując graficzny interfejs, ja się skupię na tekstowym interfejsie udostępnianym przez samo gdb. Zaczynając pracę z debuggerem, trzeba pamiętać, że program, który chcemy badać, należy skompilować podając kompilatorowi flagę -g, co powoduje dołączenie do pliku wynikowego dodatkowych informacji potrzebnych gdb.

Debugger uruchamiamy:gdb nazwaprogramuUkaże się nam wiersz poleceń gdb. Podam skróconą listę najprzydatniejszych poleceń:

help
Wywołuje pomoc programu
run [argumenty]
Uruchamia program, opcjonalnie przekazując argumenty wywołania
next
Przechodzi do następnego kroku – wywołania funkcji są traktowane jako pojedyncza instrukcja.
nexti
Przechodzi do następnej instrukcji. W przeciwieństwie do instrukcji next, ta instrukcja „wchodzi” do wewnątrz wywoływanych funkcji
continue
Kontynuuje „normalne” wykonanie programu
break [pozycja]
Dodaje breakpoint, czyli miejsce, w którym działanie programu zostanie przerwane. Argument może określać linię pliku albo nazwę funkcji.
clear
Usuwa breakpoint
watch
Dodaje watchpoint, czyli wyrażenie (np. zmienną), którego zmiana powoduje przerwanie wykonania programu.
bt
Wyświetla stos wywołań funkcji
frame numer
Przechodzi do wybranej ramki na stosie wywołań
print wyr
Wypisuje wartość wyrażenia wyr
ptype wyr
Wypisuje informację o typie wyrażenia wyr
list
Wypisuje bieżący kawałek kodu źródłowego programu

W repozytoriach znajdzuje się jeszcze program Data Display Debugger (pakiet ddd), będący graficznym interfejsem dla gdb.

gprof – profiler GNU

Czasami program działa poprawnie, ale potwornie długo. W takim wypadku można skorzystać z profilera, który pokaże wąskie gardła w programie. W repozytoriach znajdziemy program gprof, czyli profiler systemu GNU. Aby skorzystać z profilera, należy najpierw skompilować program dodając flagę -pg kompilatorowi:gcc -Wall -pg test.c -o test
Tak skompilowany program należy uruchomić i wykonać wszystkie czasochłonne czynności, których czas wykonania chcemy zmierzyć. Trzeba pamiętać, że profiler mierzy wykonania czas tylko tych funkcji, które się wykonują, a analiza nie dotyczy programu w ogóle, tylko jego konkretnego wykonania. Po zakończeniu programu, w bieżącym katalogu znajdzie się plik gmon.out. Taki plik można analizować profilerem:gprof program gmon.out > profil.txt
program to nazwa pliku wykonywalnego z programem, natomiat profil.txt to tekstowy plik z wynikami.

svn – system kontroli wersji

Częstokroć pisząc program w kilka osób, albo nawet samemu, korzystając z kilku komputerów, spotykamy się z sytuacją, kiedy zaczyna istnieć kilka wersji programu, wśród których praktycznie niemożliwym jest określić, która jest tą najnowszą, „właściwą” wersją. Połączenie wszystkich zmian dokonanych przez członków zespołu może stać się nietrywialnym zadaniem. W takiej sytuacji warto posłużyć się tzw. systemem kontroli wersji, który zarządza kodem programu. Pliki są przechowywane na serwerze w tzw. repozytorium (nie mylić z repozytoriami APT). Przed rozpoczęciem pracy, programista ściąga (ang. checkout) tzw. kopię roboczą z serwera. Po dokonaniu zmian w kodzie zatwierdza (ang. commit) poprawki. Klient systemu kontroli wersji wysyła zmiany dokonane przez użytkownika. Jeżeli ktoś wcześniej zmodyfikował zmieniony przez użytkownika fragment, tak, że poprawek nie da się wprowadzić, powstaje konflikt, który trzeba rozwiązać ręcznie.

Do niedawna najpopularniejszym systemem kontroli wersji, był CVS (ang. Concurrent Version System), który miał jednak pewne ograniczenia. Obecnie w świecie wolnego oprogramowania chyba najpopularniejszym tego typu narzędziem jest Subversion. W Ubuntu klienta znajdziemy w pakiecie subversion. Wiele serwisów hostujących projekty wolnego oprogramowania (m.in. Google Code) oferują repozytoria svn. Pracę z Subversion rozpoczynamy od pobrania kopii roboczej projektu:
svn checkout svn://host/ścieżkaDoRrepozytorium
W ten sposób na dysku będziemy mieli kopię projektu, na której można pracować. Zmiany można zatwierdzić poleceniem:
svn commit -m "Wiadomość"
Jeżeli nie pojawią się konflikty, zmiany zostaną umieszczone w repozytorium. Warto zauważyć, że wysyłane są tylko zmiany, a nie cała kopia robocza, co znacznie skraca czas przesyłania danych. Kopię roboczą można zaktualizować, bez konieczności pobierania całego repozytorium od początku:
svn update
Nowe pliki do repozytorium dodaje się poleceniem:
svn add plik1 plik2 ... plikn
svn commit #pliki nie zostaną przesłane na serwer do czasu zatwierdzenia zmian

Informację o zmianach w kopii roboczej można otrzymać poleceniem:
svn status
Log wszystkich zmian w repozytorium:
svn log | less

Oprócz Subversion istnieje wiele innych systemów kontroli wersji. Każdy ma swoje szczególne cechy, ale ogólny schemat korzystania z nich jest podobny. Do „konkurencji” Subversion zaliczają się Bazaar, darcs, git, GNU arch, Mercurial, Monotone. Jak widać, jest w czym wybierać. Na koniec jeszcze dodam, że wiele środowisk programistycznych (np. Eclipse czy Monodevelop) integruje się z niektórymi systemami, a także instnieje wiele graficznych klientów tych systemów, tak więc można korzystać z Subversion czy też innej alternatywy bez konieczności otwierania terminala.

autotools

Autotools jest zestawem narzędzi mającym ułatwić instalowanie programów ze źródeł w różnych środowiskach. Jeśli ktoś kompilował jakiś program ze źródeł, to pewnie używał skryptu configure, zawartego wraz ze źródłami. Autotools służą m.in. do stworzenia skryptu configure. Głównymi częściami pakietu są autoconf i automake. Autoconf służy do tworzenia skryptu configure na podstawie pliku zwykle nazwanego configure.in albo configure.ac, natomiast automake tworzy pliki Makefile.in z plików Makefile.am. Na podstawie plików Makefile.in skrypt configure tworzy pliki Makefile, używane przez program make przy kompilacji programu. Tworzenie plików dla narzędzi autotools jest dosyć skompilowane i wymaga kopiowania dużych ilości często niezrozumiałego kodu, tak więc wielu programistów chcąc skorzystać z systemu budowania GNU po prostu kopiuje potrzebne pliki z innych projektów a następnie je przerabia. Duża cząść IDE generuje te pliki dla użytkownika.

doxygen – tworzenie dokumentacji

Doxygen jest narzędziem tworzącym dokumentację techniczną programu na podstawie komentarzy zawartych w kodzie programu. Programista w plikach źródłowych umieszcza specjalnie sformatowane komantarze, które są odczytywane przez program Doxygen (pakiet doxygen), który na podstawie tego tworzy dokumentację zawierającą opis wszystkich funkcji, klas czy metod danego programu, w kilku różnych formatach, m.in. HTML, PDF czy strony podręcznika systemowego man.

Pisząc program, należy dokumentować każdą funkcję czy klasę:

/**
 * brief Class representing a rectangle
 **/
class Rectangle
{
	private:
		int width;	/** < Rectangle width */
		int height;	/** < Rectangle height */

	public:
		Rectnagle (int w, int h);
		int Area ();
};


/**
 * brief Rectangle constructor
 * param w Rectangle initial width
 * param h Rectangle initial height
 **/
Rectangle::Rectangle (int w, int h)
	: width (w), height (h)
{
}


/**
 * brief Compute rectnagle area
 * return Rectangle area
 **/
int Rectangle::Area ()
{
	return width * height;
}

W katalogu głównym projektu należy umieścić plik Doxyfile (który można wygenerować używając doxywizard (pakiet doxywizard). Następnie, wykonujemy polecenie doxygeni w katalogu doc znajdziemy wygenerowaną dokumentację w różnych formatach.

Oprócz Doxygen istnieją różne inne narzędzia do tego celu, jak Gtk-Doc, przeznaczony głównie do projektów związacych z GNOME, Javadoc dla języka Java, czy NDoc dla .NET/Mono.


Dodaj komentarz

Twój adres email nie zostanie opublikowany. Pola, których wypełnienie jest wymagane, są oznaczone symbolem *

53 komentarzy do “Wstęp do programowania w Linuksie na przykładzie Ubuntu

  • Kubeczek

    Całkiem ciekawy artykuł. Aczkolwiek zauważyłem, że polecasz wersje javy która nie jest całkowicie otwarta. Zaś otwarta java nie ma wcale mniejszych możliwości, a pisząc w niej mamy pewność, że nasz program będzie dobrze działał również na systemach na których nie ma jakiegokolwiek zamkniętego oprogramowania.

  • Jan Koprowski

    Fajny przegląd – naprawdę ciekawy… Brakuje mi tylko wspomnienia o valgrindzie 🙂 który napraaaawdę pozwala znajdować błędy i jest szalenie wygodnym narzędziem :] do szukania błędów w swoim sofcie.

  • Jh

    Świetny artykuł, do języków skryptowych dodałbym R (CRAN): język zasadniczo do statystki, ale ze względu na szybkość przetwarzania danych liczbowych nadaje się do wszelkich zadań obliczeniowych. Obecnie jest to najszybciej rozwijający się projekt OPEN SOURCE na świecie, więc warto go dodać do przeglądu
    pozdrawiam

  • mths

    jako początkujący programista, albo właściwie zupełny laik 😉 stwierdzam, że artykuł jest przydatny i dla ludzi takich jak ja na pewno będzie dobrym drogowskazem.

    No to jak juz mam nieco rozeznanie w temacie, to sięgam do dodatkowych źródeł i zabieram się do programowania 🙂

  • RYNIEK

    Szkoda że nie przedstawiłeś większej ilości zalet Pythona a jest ich wiele. 🙂
    PyGTK, PyQT, PyGame, wxPyhton, Pylons, Django, IronPython, Jython i jeszcze wiele innych 😉

  • soda2

    wszystko ekstra, tylko nie rozumiem czemu każesz instalować ludziom kompilator i inne rzeczy dla języka C skoro odbiorcy mogą chcieć programować np w Pascalu… Ja na ubuntu by programować w pascalu radzę sobie po sudo apt-get install fpc i żadne „build-essential” nie jest mi potrzebne.

  • Parton

    Ogólnie artykuł fajny, ale znalazłem kilka nieścisłości:
    – [quote post=”762″]Edytory i środowiska programistyczne

    Co prawda prawdziwi programiści programy piszą poleceniem cat przekierowanym do pliku, ale zanim osiągnie się taki poziom, często wygodniej jest skorzystać z wyspecjalizowanego edytora tekstu czy wręcz zintegrowanego środowiska programistycznego.[/quote]
    Totalna bzdura. Każdy „prawdziwy programista” wie oraz docenia, jak ważne w ich zawodzie jest dobre IDE. Wyobraź sobie program który ma powiedzmy 80 tyś. linijek, rozbity na 40 plików. Spróbuj nad tym zapanować bez dobrego IDE, masz racje – będzie cholernie ciężko.

    -[quote post=”762″]W odróżnieniu od innych systemów operacyjnych w Linuksie nie ma jednej biblioteki do obsługi graficznego interfejsu użytkownika.[/quote]
    W Mac os X – Cocacoa, Carbon.
    Więc jak widzisz to nie jest tak, że wszystkie systemy operacyjne mają tylko jedną bibliotekę do obsługi GUI.
    -[quote post=”762″]C

    W światku uniksowym język C ma wciąż bardzo duże zastosowanie, większość Unix-ów i systemów uinuksopodobnych jest napisana w całości w C[/quote]

    Tu tylko literówka, ma być uniksopodobnych nie uinuksopodobnych.

    Reszta jest w moich oczach całkowicie w porządku. Te kilka rzeczy, które napisałem, warto zmienić. Pozdrawiam

  • mario_7

    [quote post=”762″]Totalna bzdura. Każdy “prawdziwy programista” wie oraz docenia, jak ważne w ich zawodzie jest dobre IDE. Wyobraź sobie program który ma powiedzmy 80 tyś. linijek, rozbity na 40 plików. Spróbuj nad tym zapanować bez dobrego IDE, masz racje – będzie cholernie ciężko.[/quote]
    To miał być dowcip… Słabe masz poczucie humoru…

    [quote post=”762″]Tu tylko literówka, ma być uniksopodobnych nie uinuksopodobnych.[/quote]
    poprawione

  • Bzyk

    Ja też się czepię. 🙂
    Pierwszy akapit o „Perl”: Bash i sed nie są językami programowania. Bash to powłoka a Sed to edytor strumieniowy. Owszem, w Bashu się programuje – pisze skrypty a Seda można zaprząc do pomocy…
    No i sprawa programowania „poleceniem cat przekierowanym do pliku” – chyba poleceniem ‚echo’… cat potrafi wyświetlić zawartość pliku… Poza tym dowcip udany. Nikt nie programuje w ten sposób, nawet kilku linijek… Od tego jest vi… :>

  • zen

    Ciekawy i obszerny artykuł. Jedna mała uwaga: Eclipse nie zostało stworzone przez IBM. IBM zainicjowało powstanie Eclipse podarowując kod źródłowy VisualAge społeczności.

  • Cziterus

    [quote post=”762″]#include

    int main (int argc, char *argv[])
    {
    printf („Hello World!n”);
    return 0;
    }[/quote]

    A nie czasem printf („Hello World!n”); ? 😉

  • Abrams

    Bardzo przydatny artykół, chciałem się zając programowaniem w C , ale eclipse wydawalo mi sie bardzo skomplikowane, a dzięki niemu dowiedziałem się o code ::Blocks który bardzo mi się podoba

  • DNA DesigN

    Na temat biblioteki Allegro. Pisałem w niej jakiś czas temu i generalnie łatwo w niej napisać coś konstruktywnego. Większość potrzebnej funkcjonalności mamy już ujęte w odpowiednich metodach i strukturach, więc pozostaje tylko właściwe ich wykorzystanie. Nie polecam jej jednak do bardziej złożonych projektów z uwagi na jej małą wydajność, lepiej w tym wypadku zostać przy SDL. 😉

  • amastah

    Bardzo fajny artykuł dla początkujących
    a btw.
    [quote post=”762″]cat > plik.cpp[/quote]
    [quote] cat wypisuje na standardowe wyjście zawartość każdego podanego pliku lub standardowego wejścia[/quote]
    „>” to operator basha przekierowujący strumień danych.
    Sam cat nie zapisze ci nic do pliku więc nie zgaduj tylko czytaj manuale ;P.

    //mario_7: jedni nie mają poczucia humoru, a inni czepiają się skrótów myślowych… Co za świat… 😛

  • przemelek

    Ja w kwestii formalnej, napisałeś „W przeciwieństwie do Javy, środowisko .NET nie wymaga pisania kodu w jednym języku, można wybrać jeden z wielu”
    W skrócie – to bzdura, w mniejszym skrócie to marketingowa propaganda Microsoftu. JVM tak samo jak .NET pozwala na używanie dowolnego [choć i dla JVM i dla .NET przerobionego] języka. Np. NIE JEST możliwa kompilacja dla .NET kodu w C , który używa wielodziedziczenia, tak JVM jak i CLR z .NET nie wspierają po prostu wielodziedziczenia. Mówiąc inaczej, to użycie innych języków jest ograniczone do ich specjalnych wersji.
    Jeżeli zaś chodzi o samą możliwość użycia innych języków niż Java dla JVM, i C# dla CLR to w obu jest to możliwe.

  • capybara

    @przemelek
    „Np. NIE JEST możliwa kompilacja dla .NET kodu w C”

    A właśnie, że jest możliwa dlatego, że .NET wspiera mieszanie kodu zarządzanego przez VM z kodem niezarządzanym (natywnym).

    Natomiast prawdą jest, że dla JVM istnieje wiele innych języków np. Scala albo Groovy. Różnica między JVM a .NETem jest taka, że ta druga platforma została specjalnie zaprojektowana dla wielu języków (np. Managed C++ używa konstrukcji których nie posiada C# ale są one zapamiętywane w bytecodzie), Java natomiast była rozwijana tylko dla jednego języku – Javy.

  • przemelek

    @cypybara ale niezarządzane C pracujące z .NET to coś takiego jak JNI dla Java’y z tym, że trochę łatwiejsze. Niezarządzany kod nie jest kompilowany do CIL, i de facto nie jest wykonywany przez CLR. Czyli .NET pozwala tylko na używanie niezarządzanego kodu skompilowanego w C , ale to samo pozwala robić JVM i Python. Nie jest to więc żadna zmiana jakościowa w stosunku do wcześniejszych rozwiązań. A twierdzenie, że w .NET można programować używając C jest nieprawdziwe o tyle, że pisząc aplikację .NET musisz używać C dla .NET jeżeli chcesz by była to aplikacja .NET która działa na wszystkich implementacjach CLR, lub używać niezarządzanego C , które będzie działać tylko na danym procesorze i systemie operacyjnym. Marketingowa „prawda” głosi zaś, że możesz używać dowolnego języka dla .NET

    Czyli w rzeczywistości jest tak, że tak samo CLR z .NET jak i JVM pozwalają na używanie innych języków, problemem jest tylko sensowność tego. CIL nie był tak jak twierdzisz rozwijany dla wielu języków, początkowo był tworzony jako „maszynowa” reprezentacja C#, z czasem jednak do głosu doszedł marketing który zażyczył sobie np. zgodności z VB przez co zaczęto zmieniać CIL i CLR tak by zgodne były z VB, ale zaczęto też zmieniać sam VB by był zgodny z CLR, później powstał Managed C , który udał się świetnie [z tego co czytałem bo sam nie używałem] bo jedynym istotnym odstępstwem od standardu C było zgubienie wielodziedziczenia [nieużywanego zresztą zbyt często]. Ale stąd w .NET takie kwiatki jak dziwne wsparcie dla przeciążania operatorów, bo CLR/CIL wspiera, ale już np. VB.NET nie wspiera przez co klasa napisany w C# czy C .NET, która przeciąża operatory nie może być użyta w VB.NET przez co istnieje takie kuriozum jak zalecenie by tworząc klasy w językach takich jak C# i C mimo użycia przeciążania dostarczać też metod zastępujących operatory.

    Marketingowy slogan o tym, że w .NET użyjesz dowolnego języka sugeruje, że możesz użyć .NET do skompilowania swojego legacy kodu bez przeróbek, a to nie jest do końca prawdą 😉 Bo nie każdy program C skompilujesz przy użyciu Managed C , nie każdy kod w VB skompilujesz w VB.NET i nie każdy kod Delphi skompilujesz w Delphi.NET

  • capybara

    @przemylek

    „CIL nie był tak jak twierdzisz rozwijany dla wielu języków, początkowo był tworzony jako “maszynowa” reprezentacja C#, z czasem jednak”

    Jestem ciekawy skąd bierzesz te informacje, chodzi o CIL sprzed .NET 1.0?

    „Marketingowa “prawda” głosi zaś, że możesz używać dowolnego języka dla .NET”

    Nie wiem kto słucha takich „prawd” na pewno nie ja. Przenoszenie dowolnego języka na platformę na którą nie był przemyślany zawsze będzie wiązało się z koniecznością pewnych przeróbek i dostosowywania. Chodziło mi raczej o dostępne w CILu elementy które ułatwiają migrację nowych języków do .NETu. Nie jest to jednak bezbolesne – najlepszy przykład to sprawa z operatorami którą przytoczyłeś (notabene CIL sam w sobie nie ma specjalnego „wsparcia” dla operatorów – operator to po prostu metoda ze specjalną nazwą i flagą).

  • pthread

    Dzieki za artykul, jak dla mnie super bo dowiedzialem sie szybko cos na temat c# pod lin.
    Kiedys stukalem przez pol roku aplikacje sieciowa pod Debianem (jeszcze na jajku 2.2) i wiem ile trzeba sie nameczyc zeby cokolwiek sensownego napisac pod lin.

    Czy ktos pisze/uzywal ‚produkcyjnie’ MonoDevelop ?
    Jakie sa /- czego brakuje, no i przede wszystkim czy aplikacja bedzie dla linuxa ‚przezroczysta’ – czy po deploymencie user musi cos jeszcze dogrywac, czy postawie app na N dystrybucjach ?

    Thx

  • lyrix

    Witam,

    czy w podanej w artykule składni g -Wall -o hello hello.cpp nie ma czasem błędu. Wg mnie powinno być: g -Wall hello.cpp -o hello.

    pozdrawiam

  • el.pescado

    W manualu gcc jest napisane:

    „You can mix options and other arguments. For the most part, the order you use doesn’t matter.”

    Tak więc obie formy są poprawne, co łatwo można sprawdzić samemu;)

  • mario_7

    [quote comment=”35261″]Dlaczego nie ma w tym artykule Asma( Assemblera) ??Pojawi się w przyszłości w tym arcie?[/quote]
    Jeśli napiszesz tą część (na wzór już istniejących), to czemu nie. 😉

  • Arkadius

    [quote comment=”35264″][quote comment=”35261″]Dlaczego nie ma w tym artykule Asma( Assemblera) ??Pojawi się w przyszłości w tym arcie?[/quote]
    Jeśli napiszesz tą część (na wzór już istniejących), to czemu nie. ;)[/quote]
    Chętnie bym to zrobił ale niestety nie za dużo wiem na temat assemblera i to jeszcze w środowisko Linuxa. Właśnie zainteresował mnie ten artykuł bo chciałem pogłębić swoją niską wiedzę na temat asa w linuxie.

  • c00~

    Hm, a istnieje możliwość programowania w Delphi pod Linuxem? Słyszałem, że takie aplikacje źle się kompilują, ale wolę zapytać. ; d

  • mario_7

    [quote comment=”35419″]Hm, a istnieje możliwość programowania w Delphi pod Linuxem? Słyszałem, że takie aplikacje źle się kompilują, ale wolę zapytać. ; d[/quote]
    Delphi to w zasadzie obiektowy Pascal. Jeśli chodzi o IDE podobne do Delphi, to poczytaj sobie o środowisku Lazarus.

  • sjd

    @parton
    „Totalna bzdura. Każdy “prawdziwy programista” wie oraz docenia, jak ważne w ich zawodzie jest dobre IDE. Wyobraź sobie program który ma powiedzmy 80 tyś. linijek, rozbity na 40 plików. Spróbuj nad tym zapanować bez dobrego IDE, masz racje – będzie cholernie ciężko.”

    Totalne bzdury piszesz kolego o tych totalnych bzdurach. Pisz za siebie ze ty nie uzywasz i ze tobie by bylo trudno itd.
    Uzywam edytora ed od lat (juz tak od okolo 20) nawet do projektow na 200kSLOC w wielu plikach, w roznych jezykach.
    Kolorowania skladni to w nim nie ma tylko po co by mialo byc zeby wprowadzac sie w blad – zaden edytor nie koloruje poprawnie skladni w kazdym przypadku a ten jeden gdy zrobi to zle moze kosztowac wiele dni dodatkowej pracy lub trudny do znalezienia blad ktory ujawni sie dopiero u klienta.
    Jesli dodac do ed kilkanascie funkcji/programow to zadne ide sie z nim nie rowna.
    Przykladowo otworz w Eclipse czy nawet w VIM czy w innym swoim ulubionym edytorze plik textowy 4GB i pracuj na nim. Powodzenia bo sie przyda. W ed otwieram taki plik na PC z 8MB ram (NetBSD) i smiga jak odrzutowiec concorde.
    Ed zajmuje na dysku az okolo 50kB (kilo to nie pomylka).
    Pewnie tobie bedzie „cholernie ciezko” bo absolutnie nic w nim nie mozna kliknac (natywnie bo uzywajac gpm mozna swobodnie kopiowac mysza 🙂 )

    Art. bardzo ciekawy jako wprowadzenie choc sporo by trzeba poprawic i uzupelnic.
    Krytykantami sie nie przejmuj zawsze sie znajdzie taki co mu sie cos nie spodoba.

  • MasterMatan

    Super stronka, bardzo pomogło i pomaga do dziś. Kieruję na tę stronkę wszystkich którzy zaczynają przygodę z programowaniem pod Linuksem.
    Pozdrawiam

  • Adam

    Dzięki za super artykuł.
    Czy można dodać coś o Lispie, np. :

    # in console :

    # to instal sbcl , emacs, slime and cl-swank

    sudo apt-get install slime cl-swank sbcl

    # ??

    echo ‚(setq inferior-lisp-program „sbcl”)’ >> ~/.emacs

    # run emacs

    emacs

    # in emacs :

    ; to switch to slime

    M-x-slime

    ; ( it means press Alt (and do not release ) and x, type slime )

    ; Now you are in Lisp ( sbcl)

    pozdrawiam

    Adam

  • negocjatorek

    A czy może mi pomóc ktoś opanować code::blockS ? Jestem na linuxie od 2 dni i co prawda kompilowanie w terminalu opanowałem, ale najwygodniejsze to to nie jest a ani w code::block ani w codeLite nie moge się połapać jak zbudować mój plik wykonywalny… Pomoże ktoś? programuje w C++ i chciałbym tworzyc aplikacje konsolowe.

  • Pyku

    Wielce pomocny artykuł, duża ilość informacji „na początek” zgromadzona w jednym miejscu i ładnie oprawiona.

    Dzięki! 🙂

    Btw. bardzo mi się podobają ludzie, którzy czytają artykuł, tylko po to, aby go skrytykować; może to jest jakiś sposób na nudę po kompletnym poznaniu wiedzy tego świata?

  • Reiko

    Witam,

    ja mam problem z uruchamianiem programów skompilowanych g++. Gdy program zostanie skompilowany, owszem – pojawia się a.out ale gdy wpisuje ./a.out – dostaję komunikat „Brak dostępu”. Jak to obejść? Jestem nowy w linuxie.