januari 05, 2009

Isomorfa ord (Isomorphic Words) - programmet

2004 skrevs programmet Isomorphic words som söker efter isomorfa ord till ett givet källord. Programmet och begreppet "isomorfa ord" presenterades i Isomorfa ord (Isomorphic Words).

För ett tag sedan kom en förfrågan om källkoden till programmet, varpå en CLI (Command Line Interface)-version av webb-programmet skapades. Tänkte nu att programmet likaväl kunde komma till allmänhetens fromma.

isomorphic_words.py
Programmet isomorphic_words.py är ett Pythonprogram som gör i stort sett allting som CGI-programmet gör. Syntaxen är:

     python isomorphic_words.py word exact_match language

där argumenten har följande betydelse:

* word: ordet som ska isomorferas.
* exact_match: 0 eller 1 (default 1). Om det ska göras en exakt match eller inte. Se ovanstående länkar för betydelsen av detta.
* language: Språk, eller snarare ordlista. CLI-programmet stöder endast språk "eng" som är kopplat till ordlistan /usr/dict/words (standardplaceringen i Linux). Av copyright-skäl etc lämnas inte den svenska ordlistan ut.


Exempel
Här är en exempelkörning på "ordet" (snarare strukturen) abbab, dvs att första och fjärde bokstäverna ska vara samma, och andra, tredje och femte bokstäverna ska vara samma. Ordlistan är /usr/dict/words, dvs engelska ord.


     python isomorphic_words.py abbab

Med resultatet:


Word: abbab
Word structure of 'abbab': [0, 1, 1, 0, 1]
Exact isomorphism: yes
Language: english
Print mappings: yes

beebe
2 chars: "a" -> "b"
3 chars: "b" -> "e"

esses
2 chars: "a" -> "e"
3 chars: "b" -> "s"

poopo
2 chars: "a" -> "p"
3 chars: "b" -> "o"

taata
2 chars: "a" -> "t"
3 chars: "b" -> "a"


It was 4 isomorphics words to 'abbab', with exact isomorphism: yes


Not
Om programmet används får det gärna refereras till ovanstående program och/eller till undertecknad.

Posted by hakank at 11:00 FM Posted to Språk | Systemutveckling

januari 04, 2009

Programspråket Icon och några Project Euler problem

Programspråket Icon och dess något mer aktiva objektorienterade dialekt Unicon (the Unified Extended Dialect of Icon) är ett underskattat språk. Tyvärr utvecklas det inte längre lika aktivt som tidigare av dess grundare (och det är säkert en orsak till underskattningen), men Unicon-projektet håller fortfarande på med skoj utökningar, t.ex. en SNOBOL-liknande strängmatchning.

Icon/Unicon är ett trevlig programspråk med flera ganska unika egenskaper:
- strängmatchningen. Det finns stöd för reguljära uttryck via regex.icn, men man bör först lära känna Icons egen variant som är en utveckling av SNOBOLs patterns
- "målinriktad" programmering, där success och fail avgör programmets flöde (via t.ex. en slags backtracking)
- generatorer med every och "alternattion" (se mina Mankell-skriverier nedan för mer exempel)
- co-expressions (används inte här nedan)
- det har ett drag av funktionsprogramming som tilltalar mig
- det finns ett stort antal exempel och moduler


Project Euler
Jag tänkte här inte prata så mycket om språket som visa några exempel rakt av (se referenserna nedan för mer introducerande material om språket). För detta används de tio första problemen från Project Euler, en sajt med veckoliga programmerings-/matematiska problem där man måste ange lösningen (i form av ett tal) för att komma vidare och läsa andras ofta kreativa lösningar (och p.g.a. detta visas endast programkoden, inte resultatet). De samlade Euler Project-problemen finns här.

Tilläggas kan att mitt Project Euler-ande började under mitt Lisp-skov för några år sedan och jag tenderar att göra åtminstone de första - säg - 20 problemen i programmeringsspråk som jag vill kolla in (såsom t.ex. Pop-11 i höstas; eventuellt kommer en snarlik bloggning om detta).

Nedanstående exempel antyder möjligen att Icon är ett språk för att hantera tal, vilket är lite olyckligt eftersom dess styrka snarare ligger i att hantera text/strängar (och datastrukturer). Detta sagt så skrevs flera artiklar i Icon Analyst om generering av olika talsekvenser.

Hursomhelst, här är programkoden för de 10 första Project Euler-problemen. I vissa fall visas även några (bortkommenterade) varianter av lösningar.



# some libraries used
link patterns, scan, factors, numbers, matrix, math

#
# The mandatory main procedure
#
procedure main()

problem1()
# problem2()
# problem3()
# problem4()
# problem5()
# problem6()
# problem7()
# problem8()
# problem9()
# problem10()
end

Problem 1

# If we list all the natural numbers below 10 that are multiples of 3 or 5,
# we get 3, 5, 6 and 9. The sum of these multiples is 23.
#
# Find the sum of all the multiples of 3 or 5 below 1000.
procedure problem1()
s := 0;
every s +:= mult3_or_5(1 to 999)
write(s)
end

procedure mult3_or_5(n)
# if n % 3 == 0 | n % 5 == 0 then
if n % (3|5) == 0 then
suspend n
end


Problem 2

# Each new term in the Fibonacci sequence is generated by adding the
# previous two terms. By starting with 1 and 2, the first 10 terms will be:
#
# 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...
#
# Find the sum of all the even-valued terms in the sequence which do not
# exceed four million.
procedure problem2()
local s := 0
every s +:= fib_test(1 to 100)
write(s)

end

# For problem 2
procedure fib_test(n)
if (f := fib(n)) % 2 == 0 & f < 4000000 then return f
end

procedure fib(n)
nfib := 2;
prevfib :=1
currfib :=1
while nfib prevfib :=: currfib
currfib +:= prevfib
nfib +:= 1
}
return currfib
end


Problem 3

# The prime factors of 13195 are 5, 7, 13 and 29.
# What is the largest prime factor of the number 600851475143 ?

# pfactors from ipl/procs/factors.icn
procedure problem3()

L := pfactors(600851475143)
write(L[*L]) # write the last value

end


Problem 4

# A palindromic number reads the same both ways. The largest palindrome made
# from the product of two 2-digit numbers is 9009 = 91 × 99.
#
# Find the largest palindrome made from the product of two 3-digit numbers.
procedure problem4()

# Three different versions

## List solution:
# L := []
# every push(L, numeric(palindrome(string( (100 to 999) * (100 to 999)))))
# write(myMax(L))

## Hash table solution:
# H := table(0)
# every H[numeric(palindrome(string( (100 to 999) * (100 to 999))))]:=1
## sort(H,3) sorts on values och returns a list of
## 2*keys entries [key1, value2, key2, value2, etc]
# We want the penultimate element keyxxx in [...,keyxxx, valuexxx]
# L := sort(H,3)
# write(L[*L-1])

# Set solution
local S := set()
every insert(S, numeric(palindrome(string( (100 to 999) * (100 to 999)))))
L := []
every push(L, !S) # and converts to a list
write(myMax(L))

end

procedure myMax(L)

local maximum := get(L)
every maximum <:= !L

return(maximum)

end

procedure palindrome(s)
if s == reverse(s) then return s
end


Problem 5

# 2520 is the smallest number that can be divided by each of the numbers
# from 1 to 10 without any remainder.
#
# What is the smallest number that is evenly divisible by all of the numbers
# from 1 to 20?
procedure problem5()
L:= [];
every put(L, (1 to 20))
write(myLCM(L))

# alternative solution using lcml from library factors.icn
# write(lcml(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20))

end


# inspired by lcml in numbers.icn
procedure myLCM(L)
i := get(L)
while j := get(L) do
i := lcm(i, j)

return i
end


Problem 6

# The sum of the squares of the first ten natural numbers is,
# 1^(2) + 2^(2) + ... + 10^(2) = 385
#
# The square of the sum of the first ten natural numbers is,
# (1 + 2 + ... + 10)^(2) = 55^(2) = 3025
#
# Hence the difference between the sum of the squares of the first ten
# natural numbers and the square of the sum is 3025 − 385 = 2640.
#
# Find the difference between the sum of the squares of the first one
# hundred natural numbers and the square of the sum.
procedure problem6()
L := []
sum_squares := 0;
square_sum := 0;
every put(L, (1 to 100))
every sum_squares +:= !L^2

every square_sum +:= !L
square_sum := square_sum^2
d := square_sum - sum_squares
write(square_sum, " - ", sum_squares, " = ", d)

end


Problem 7

# By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see
# that the 6^(th) prime is 13.
#
# What is the 10001^(st) prime number?
procedure problem7()
local p;
# prime() is from numbers.icn and is defined thusly:
# suspend 2 | ((i := seq(3, 2)) & (not(i = (k := (3 to sqrt(i) by 2)) * (i / k))) & i)

# Generate the primes and stop at the 10001:th
every p := prime() \ 10001
write(p)

end


Problem 8

# Find the greatest product of five consecutive digits in the 1000-digit number.
# 73167176531330624919225119674426574742355349194934
# 96983520312774506326239578318016984801869478851843
# 85861560789112949495459501737958331952853208805511
# 12540698747158523863050715693290963295227443043557
# 66896648950445244523161731856403098711121722383113
# 62229893423380308135336276614282806444486645238749
# 30358907296290491560440772390713810515859307960866
# 70172427121883998797908792274921901699720888093776
# 65727333001053367881220235421809751254540594752243
# 52584907711670556013604839586446706324415722155397
# 53697817977846174064955149290862569321978468622482
# 83972241375657056057490261407972968652414535100474
# 82166370484403199890008895243450658541227588666881
# 16427171479924442928230863465674813919123162824586
# 17866458359124566529476545682848912883142607690042
# 24219022671055626321111109370544217506941658960408
# 07198403850962455444362981230987879927244284909188
# 84580156166097919133875499200524063689912560717606
# 05886116467109405077541002256983155200055935729725
# 71636269561882670428252483600823257530420752963450
procedure problem8()
n := "7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450";

## using lists
# L := []
# every i := (1 to (*n)-5 ) do {
# s := n[i:i+5] # string segment
# p := 1
# every p *:= !s # converts automatically to numbers
# put(L, p)
# }
# write(myMax(L))

# using string matching
this_max := 0
n ? {
while x := move(5) do {
move(-4)
p := product(x)
if p > this_max then
this_max := p
}
}

write("this_max: ", this_max)

end


Problem 9

# A Pythagorean triplet is a set of three natural numbers,
# a < b < c, for which, a^(2) + b^(2) = c^(2)
#
# For example, 3^(2) + 4^(2) = 9 + 16 = 25 = 5^(2).
#
# There exists exactly one Pythagorean triplet for which a + b + c = 1000.
# Find the product abc.
procedure problem9()

every c := 1 to 500 &
b := 1 to c &
a := 1 to b &
a + b + c = 1000 &
a^2 + b^2 = c^2
do {
write(a, "^2 + ", b, "^2 = ", c, "^2", " : ", a*b*c) & fail
}
end


Problem 10

# The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.
#
# Find the sum of all the primes below two million.
procedure problem10()
s := 0
n := 2000000

every p := p10(n) & p < n & s +:= p
write(s)
end

procedure p10(n)
# prime() from factors.icn
suspend p:= prime() do
if p > n-1 then fail
end

Se även
Tidigare skriverier om Icon:
Programspråket Icon och stavningen av "Henning Mankell"
Fortsatt stavning av "Henning Mankell". Samt lite om agrep
Skapa strängar från reguljära uttryck - eller: Tystnaden de senaste dagarna


Huvudsajter
Icon
Unicon

Education och där speciellt Books där referensverken finns nedladdningsbara. Se speciellt The Icon Analyst var en tidskrift som innehöll intrikata artiklar om Icon såväl på bredden som på djupet.
Nyhetsgruppen comp.lang.icon ("Låg aktivitet")


För Unicon:
The Unicon book (PDF)
Mailing lista

Se även Wikipediasidorna
Icon (programming language)
Unicon (programming_language)
SNOBOL (som för övrigt råkade ut för en liten Wikipedia-skärmytsling förra veckan).

Posted by hakank at 09:53 FM Posted to Pyssel | Systemutveckling

oktober 22, 2008

Complete Rewrite: Intressant blogg om databaser och systemutveckling

Complete Rewrite är en ny intressant blogg om Personal viewpoints on database systems and computer programming.

Författaren, Jesper Larsson, presenterar sig så här:

Passionate programmer since I got my first programmable calculator in 1985, my work developing search engine and data management software, as well as my own understanding of database systems and software design, at Apptus Technologies has taken me quite some distance from my background as a practical algorithm theoretician with Ph.D. on suffix trees and data compression, and allowed me to develop insights and opinions on such diverse areas as object-oriented design, the relational data model, transactional systems, development processes, and logic.

Till dags dato har skrivits två (långa) artiklar:

* Why the Database Masters Fail Us

There is hardly any field in computing more plagued by religious wars than database systems. For nearly 40 years, the battle has raged between various architechtures, occasionally with some combattants replaced – or at least renamed. Still, it seems that we are further away than ever from a sort of database that we can be satisfied with. (I am not going into the details of the problems right now, that will be a subject of future posts. But if you are in the business I am sure you are familiar with some of them.)
...


* Text search and relational model

It is particularly common to write off the relational model in the text search field. You can frequently hear people say that things like the relational model is not suitable for capturing the structure of text, or referring to text by the peculiar term “unstructured data”. Some writers talk about combining text and relational data, as if there were a contradiction. As if relational data were a special kind of data. A more correct account, like that of Curt Monash, is to simply note that text does not work very well with the architecture of mainstream relational products – which is true.
...
Since text search is one of my top areas of expertise, I hope I can explain to you why the relational model is perfectly capable of capturing the structure of text. I'll start at the very bottom, explaining what text search really is.

Eventuellt bör nämnas att jag känner Jesper, han är en både smart och klok (samt trevlig) person.

Posted by hakank at 06:36 EM Posted to Blogging | Systemutveckling | Comments (3)

april 26, 2007

Programspråket Groovy: Tre år senare

För mer än tre år sedan skrevs om det då sprillans nya programspråket Groovy. Det har hänt en hel del sedan dess, men först lite mer om Groovy.


Groovy är ett "agilt" programspråk likt Ruby, JRuby, Python, Jython, Perl etc, dvs det som numera inte så ofta kallas för "script-språk" och som man ibland kallar för VHLL (Very High Level Language). Det finns alltså många högnivåkonstruktioner i dessa språk och man kan köra program utan att behöva kompilera till exekverbar kod (eller bytekod). Liksom JRuby och Jython inriktar Groovy sig på Java-världen och använder sig av Java .class-filer och kan även generera bytecode.

På sajten sin presenterar man sig så här:

[Groovy] is an agile dynamic language for the Java Platform with many features that are inspired by languages like Python, Ruby and Smalltalk, making modern programming features available to Java developers with almost-zero learning curve

eller - för att citera boken Groovy in Action (se ref. nedan) - “Java-stylish with a Ruby-esque feeling”.


Det har hänt en hel del sedan jag först stötte på språket. Framför allt var det två saker som gjorde att jag tog upp intresset igen för några veckor sedan:
* det har blivit så stabilt så att version 1.0 skeppades i januari, och man håller just nu på med att förbereda releasen 1.1 (lagom till JavaOne)
* det har kommit ett par böcker om språket, varav den ena "Groovy in Action" har lästs och beskrivs mer nedan.

Och i går vann man första pris på JAX 2007 ("the most important Java conference in Germany"): Groovy wins first prize at JAX 2007 innovation award. Kul!

Findings eller Saker som är skoj med Groovy
Jag tänker här inte skriva någon introduktionskurs kring Groovy. Sådant finns på/via sajten eller annorstädes. I stället kommer här några disparata findings om saker är trevligt/speciellt i språket samt några gotchas. Exemplen råkar vara mycket med text och tal eftersom det ju är sådant som jag sitter med här hemma...


För att undanröja framtida kommentarer: Ja, jag vet att mycket (eller allt) som beskrivs här är möjligt att göra i andra programspråk, speciellt i de agila kusinerna. Frågan är inte så mycket att utan snarare hur (se nedan om syntaktiskt socker). För tillfället ligger Groovy mycket högt på min lista över språk som känns bra att skriva, även om jag egentligen inte tillhör den direkta målgruppen ("Javautvecklare som vill blir effektivare" som man uttrycker det i reklamen).


Synkaktiskt socker eller En liten skillnad gör många tangentnedtrycksbesparingar
Eftersom jag hävdar (utan att argumentera) att "syntaktiskt socker i ett programspråk är allt" passar det bra med ett litet exempel: Följande lilla skillnad mellan Ruby och Groovy gör att Groovy känns bättre, nämligen hur man skriver closurevariabeln. Med ett svenskt tangentbord är det meckigare att trycka Alt-Gr-"|" + x + Alt-Gr-"|" än "-" + ">" + "x" samt att skriva "#{}" än "$". Efter några år har man sparat förfärligt många tangenttryckningar med Groovys variant...

Ruby:

(1..10).each{ | x | print "#{x}" }

Groovy:

(1..10).each{ x -> print "$x " }

(1..10).each{ print it }

Det andra Groovy-exemplet visar att det finns en magisk variabel it som man kan använda direkt så man slipper deklarera någon temporär variabel. Fler tangenter som slits mindre. (Ruby har haft en sådan variabel $_ men det är tyvärr deprekerad sedan ett tag. Jepp, jag tycker att Perl är ett mycket trevligt språk.)

Å andra sidan: om det viktigaste är att spara tangenttryckningar bör man titta på programspråket J.

Lite avstickare: önskefeatures i ett programspråk
Ovanstående ska ses som ett exempel på vad jag tycker är trevligt med både Ruby och Groovy, nämligen att allt är objekt och att det finns någon form av stöd för funktionsprogrammering (ju mer stöd desto bättre).

Båda språken uppfyller många av mina önskefeatures för programspråk:

* fullständigt objektorienterat med "öppna klasser". Groovy har inte helt öppet som Ruby, men det går att öppna upp med vissa handgrepp. Se nedan.

* direkt stöd för hashtabeller i språket, dvs literaler: {"x"=> 1, "y"=>2} och vektorer: [1,2,3,4]. Gärna också intervall: (1..10)

* stöd för reguljära uttryck direkt i språket ("=~" som ju Perl och Ruby också har)

* stöd för funktions(liknande)programmering med syntaktiskt tilltalande sätt att arbeta med dem. Exempelvis: closures och möjlighet till obegränsad kedjning (chaining). (Chaining ett mycket trevlig programmeringsparadigm. Att jag tycker om både chaining och Unix-filosofin med att pipa text mellan program är definitivt ingen slump. Snarare tvärtom.)

* automatiskt stöd för arbiträr precision så att man kan göra roliga matematiska experiment. I Groovy måste man i och för sig ange "G" i slutet på ett tal om det ska räknas arbiträrt. Man kan göra saker som

(2..10).each{mod->(1..100).findAll{it % mod ==0}.inject(1G){x,y -> y*=x}.each{ println it} }

för att summera tal som är jämt delbara med ett visst tal. Notera att det krävs "1G". (Att jag inte vill se sådan kod i driftade program är en annan sak.)

* snabb loop över filer. I Groovy finns det syntaktiska sockret men är tyvärr lite långsamt. Se mer nedan.

* list comprehension som Haskell (och Python). Saknas tyvärr i Groovy (samt i Ruby och Perl)

Allt är objekt
En sak som jag brukar testa i ett nya programspråk som hävdar att "allt är objekt" är följande oerhört fåniga exempel. Notera att man måste använda en så kallad category (eller så kan man använda MetaClass men det känns inte så rent) för att öppna upp existerande klasser, i detta fall Number (i Ruby är det ju bara att öppna upp klassen).


class HakankCategory {
static def hakank(Object self) {
return "hakank väljer $self"
}

static def hakank(Object self, Number number) {
return "hakank väljer $self och $number"
}
}

use(HakankCategory) {
println 1.hakank()
println 1.hakank(2)
}

Kör man programmet (groovy program.groovy kommer följande:


hakank väljer 1
hakank väljer 1 och 2


Man kan här notera att Groovy stödjer "strikt typning" men det är inte nödvändigt att deklarera variabler med typer.

Direkt stöd för Java
Till skillnad från JRuby och Jython använder man i Groovy Java-liknande syntax för att anropa existerande Java-klasser. Ja, hela syntaxen i Groovy är mycket Java-liknande (förutom några saker såsom "def" för att definiera en variabel).

T.ex. följande lilla exempel använder det numeriska paketet Colt ("a set of Open Source Libraries for High Performance Scientific and Technical Computing in Java"):

import cern.jet.math.Artihmetic.*

cc = (0..10).collect{[it, cern.jet.math.Arithmetic.binomial(10,it)]}
println "cc: $cc"
println cc.collect{ it[1]}.sum()


Om man redan inte har colt*.jar-filerna i sin CLASSPATH är det bara att lägga in dem i katalogen ~/.groovy/lib så fixar Groovy resten. Sådant är trevligt.

CLASSPATH
Apropå CLASSPATH. Om det blir problem att köra programmen är det lämpligt att rensa CLASSPATH fulltständigt så att det inte blir konflikter med de versioner av paketen som följer med Groovy (t.ex. ant*.jar och antlr*.jar). Själva har jag rensat CLASSPATH direkt i samtliga program:

groovy
groovysh
groocyc
java2groovy

Filhantering
Naturligtvis finns det även agilt stöd för filhantering i Groovy. Nedanstående exempel visar även att man kan använda programmet direkt från kommandoraden för att lista filer som finns i den aktuella katalogen

groovy -e "new File('.').eachFileRecurse { println it }"


Ett annat exempel som jag använder för att testa filhantering i nya programspråk är hur snabbt det är att läsa och betarbeta filer, framför allt med reguljära uttryck. Följande har råkat bli en standardtest:


println new File("/usr/dict/words").grep(~/.*a.*b.*.c.*d.*e.*/).join("\n")

som läser ordlistan "/usr/dict/words" (standard på Linux-system) och listar de ord som någonstans innehåller alfabetets första fem bokstäver i ordning, med eller utan andra bokstäver emellan.


Just detta är en sak som gjorde mig lite besviken eftersom filhanteringen tog ungefär två gånger lång tid som motsvarande program för Ruby, Python och Perl. Förhoppningsvis är det något som kommer att fixa sig i framtida versioner. Utvecklingsversionen (blivande 1.1) skiljer sig inte nämnvärt i detta hänseende.

Builders
En annan trevlig sak är de s.k. builders, dvs stöd för att skapa olika typer av strukturer.

Ett exempel: För att skapa en (enkel) XML-fil skriver man ungefär så här (eller snarare exakt så om man liksom jag snor rakt av från sidan 235 i Groovy in Action). Man blandar alltså tag-namnen med full exekverbar kod. Notera att man inte behöver fördeklarera tag-namnen ("description", "number", "factor") utan det listas ut av buildern.


builder = new groovy.xml.MarkupBuilder()
builder.numbers {
description 'Squares and factors of 10..15'
for (i in 10..15) {
number (value: i, square: i*i) {
for (j in 2.. if (i % j == 0) {
factor (value: j)
}
}
}
}
}

resultatet blir:


<numbers>
<description>Squares and factors of 10..15</description>
<number square='100' value='10'>
<factor value='2' />
<factor value='5' />
</number>
<number square='121' value='11' />
<number square='144' value='12'>
<factor value='2' />
<factor value='3' />
<factor value='4' />
<factor value='6' />
</number>
<number square='169' value='13' />
<number square='196' value='14'>
<factor value='2' />
<factor value='7' />
</number>
<number square='225' value='15'>
<factor value='3' />
<factor value='5' />
</number>

GPath
GPath är ett XPath-inspirerat sätt att navigera sig genom datastrukturer (t.ex. XML-kod).

Ett enkelt exempel där man ska tänka sig att navigera en fet XML-fil (här som en textsträng):

def text = """
<characters>
<props>
<prop>dd</prop>
</props>
<character id="1" name="Wallace">
<likes point="2">cheese</likes>
</character>
<character id="2" name="Gromit">
<likes point="10">sleep</likes>
</character>
</characters>
"""

def node = new XmlSlurper().parseText(text);
println "\n" + node.children().size()
// Vad tycker Gromit om?
println node.character.find { it['@name'] == 'Gromit' }.likes.text()

Resultatet blir inte helt förvånande

3
sleep

Skalet groovysh
Ett agilt programspråk utan skal är otänkbart (eller i alla fall ofullständigt). T.ex. irb för Ruby, ipython för Python och perl -de 1 (eller zoid) för Perl. Så det finns naturligtvis ett sådant även för Groovy. Tyvärr är det väldigt rudimentärt, men det kommer att utvecklare mer senare.

Några saker att tänka på:

1. En egenhet är att man måste skriva "go" + Enter för att exekvera koden. Tanken är att man ska kunna skriva t.ex. en hel klassdefinition utan att störa parsern.

2. Det finns ingen history, inga redigeringsmöjligheter eller tabb-komplettering/"automatintrospektion" (dvs att som i irb/ipython skriva en variabel + TAB för att se metoder etc). De två första avhjälps enklast genom att använda en readline-wrapper såsom rlwrap. När det gäller introspektionen får man skriva så här

groovy> x = "kalle har en häst"
groovy> go

===> kalle har en häst

groovy> x.class.methods.name.sort()
groovy> go
...


3. Man bör vara försiktig med att deklarera variabler med def eftersom de är lokala variabler i det aktuella "go-blocket" och kan inte nås senare. Om man skippar def så går det bra.


Stöd för systemanrop
En annan vanlig här hemma är att anropa andra program, framförallt Unix-utiliteter såsom find, ls, wget, lynx etc. En del av funktionaliteten finns inbyggt i Groovy eller i Javas standardbibliotek som lätt kan anropas, såsom ovanstående exemplet med Dir, men där finns ju inte alla optioner man vill utnyttja.

Standardstödet för systemanrop i Groovy är i stort sett Javas exec, vilket inte räcker till. Det finns dock ett extra-paket Process (Groosh) som gör livet enklare för sådan hantering. T.ex. för att anropa programmet find för att lista .java-filer (notera att metoden findfinns inte definierad i Groosh utan "dispatchas" magiskt till ett systemanrop):


def gsh = new com.baulsupp.groovy.groosh.Groosh();
println (gsh.find(".", "-name", "*.java").toStringOut())

Här kan också nämnas en gotcha. Eftersom grep är en existerande metod i Groovy blir det namnkonflikt om man försöker anropa programmet via Groosh (kanske löses sådant i en senare version av Groosh?). Lösningen är att göra en enkel wrapper för grep (kallad grepwrapper)

#!/bin/sh

grep $*

Varför följande kan skrivas för att visa rader med strängen Gina (förkortningen för Groovy In Action)

gsh.grepwrapper("Gina", "*.groovy").toStdOut()


En aside om "dispatchern". Samma funktionalitet (i alla fall vad gäller själva anropsdelen av kommandot) kan enkelt göras i Ruby med hjälp av metoden missing_methods tack vare Rubys inbyggda stöd för systemanrop:

# Ruby-kod
class Missing
def method_missing(name, *args)
name_s = name.to_s
args_s = args.join(" ")
puts "Running #{name_s} #{args_s}:"
if (name_s =~ /rm/)
"Please don't do that: #{name_s}"
else
`#{name_s} #{args_s}` # det kan vara svårt att se att det är backticks här
end
end
end

m = Missing.new
puts m.ls("-lat *.groovy")
puts ""
puts m.du "-h"
puts ""
puts m.df
puts ""
puts m.rm
puts ""


I Perl används naturligtvis AUTOLOAD för samma funktionalitet:

# Perl-kod
sub AUTOLOAD {
my $program = our $AUTOLOAD;
$program =~ s/.*:://; # trim package name
system($program, @_);
}

date();
who('am', 'i');
ls('-l'); # man kan dock inte använda globs här, dvs *.pl
echo("Abadugabudabuda...");


Slut på asiden.


Annat skoj
* Integrerat stöd för Ant, dvs där man kan skriva Antanrop i Groovy-program: Groovy Ant Task
* Safe navigation, för att slippa kontrollera mot null hela tiden.
* GSQL ett högnivå-wrapper kring databasanrop.
* Olika stöd för testning: Testing Guide såsom JUnit-liknande modul, GroovyMocks etc.

Grails
Det går inte att komma undan utan att åtminstone nämna Grails (Groovy on Rails), ett Ruby On Rails-liknande ramverk. Det var synnerligen enkelt att få igång det efter instruktionerna men jag har inte gjort så mycket mer med det sedan.

Böcker
Det finns några böcker skrivna om språket eller relaterat.

* Groovy in Action (ISBN: 1932394842, ISBN13: 9781932394849, se även förlagets sida). Detta är Groovy-bibeln och som jag har läst med andakt. Det slår igenom (nästan alltid på ett positivt sätt) att författarna, som tillhör Groovys innersta krets, är stolta över sitt språk.

Det förutsättes i princip att läsaren är systemutvecklare så man går rätt snabbt djupt ner i "the goory details" och jämföra med Java, men även med andra agila programspråk. Speciellt intressant är kapitllen om closures, om de speciella "builders" som finns med i programpaketet samt diskussionerna varför de designat språket som de gjort.

(Jag hoppas nu att de gör en "Pickaxe" och lägger upp boken fritt tillgänglig på nätet, dvs som Ruby-gänget gjorde med första upplagan av Programming Ruby.)


* Groovy Programming - An Introduction for Java Developers (ISBN: 0123725070, ISBN13: 9780123725073) som jag inte läst. Det verkar dock vara en mer introducerande bok där man inte går in på djupet så mycket som "Groovy in Action". Men som sagt, jag har inte läst den. Se vidare bokens hemsida. Intressant nog finns där ett paket för funktionsprogrammering (i zipfilen GroovyBook). Jag var dock tvungen att kompilera om jar-filen (src/fp/fp.jar) för att det skulle fungera.


* om Grails: The Definitive Guide to Grails (ISBN: 1590597583, ISBN13: 9781590597583). Har inte läst den men den rekommenderas av andra.


* Det är åtminstone ännu en bok på gång: Groovy Recipes - Greasing the Wheels of Java (ISBN: 0978739299, ISBN13: 9780978739294), beräknad leveranstid slutet på augusti 2007. På beskrivningen verkar detta vara en kokbok.

Se även
Groovys metoder: GDK (Groovy JDK)

PDF av hela online-dokumentationen på groovy.codehouse (stor fel PDF-fil på nästan 600 sidor).

Mailinglistor:
groovy.user
groovy.dev
(Tyvärr har man tagit bort den rena textvarianten av arkivet.)


aboutGroovy
Samlingsbloggen Groovyblogs
Sven Haiges blog som bl.a. innehåller Groovy/Grails podcasts.

Groovys projektledare Guillaume Laforge har en bra föreläsning om Groovy i Simplifying Enterprise Development with Groovy. Föreläsningen var förra året innan man hunnit fixat allting till version 1.0 så vissa av exemplen visar viss förlegad kod som inte är fullt körbar. Men principen framgår tydligt.


Groovy User Guide.


Utvecklingsversionen finns här (subversionsrespositorium).

PLEAC - Groovy. PLEAC - (Programming Language Examples Alike Cookbook) har utgått från Perl Cookbook och visar hur andra programspråk löser samma problem ("lagar samma maträtter"). Intressant nog är Groovy det första programspråk som blev klar till 100% (förutom Perl då). Emellanåt visas en princip som är viktig (men som i och för sig kan upplevas som fusk i sammanhanget): Om det inte finns direkt stöd för en sak i Groovy använder en existerande Java-klass i Java (direkt i Javadistributionen eller Open Source).

En Sudoku solver in Groovy för er som kommer ihåg det glada 2006. :-)


För den som är intresserad av olika programspråk rekommenderas Programming Language News.

Posted by hakank at 10:20 EM Posted to Systemutveckling | Comments (1)

januari 25, 2006

Word Meld Simple - en etyd med Ajax-tekniken

Som några andra bloggare leker jag lite med Ajax-tekniken, vilket pratas mer om nedan.

Men först något om själva programmet.


Word Meld Simple
Word Meld är ett program som försöker att skapa "kreativa" ord (helst skulle det vara "roliga", men det är lite väl förmätet) utifrån ett grundord och ord från en ordlista, genom att leta upp gemensamma prefix och suffix.

En nyss utvecklad variant är Word Meld Simple som använder en enklare strategi: Utifrån två givna ord föresöker programmet att vara kreativ genom att lista ut gemensamma prefix/suffix samt n-gram (infix). Det är alltså detta program som använder Ajax-tekniken.


Exempel
Användningsområdet för slika program är inte speciellt klart, men en tanke är att om två företag skulle gå ihop kan programmet vara till hjälp för att skapa det nya företagsnamnet. T.ex. om google och Microsoft skulle slå ihop sina påsar (hädiska tanke!) föreslår programmet två kombinationer:

gooft
microsogle

varav det ena förslaget (det andra) ju inte låter så dåligt.

Andra tankar är att man tycker att en kombination av två ord är för lång och man vill slå ihop dem till ett enda. T.ex. statistiskt och signifikant:

signifikatistiskt
signifikt
signifiskt
stant
statistikant
statistisignifikant
statistiskant

Nå, det kanske inte blir så mycket enklare, men det är i alla fall ett ord.

En ytterligare användning är - naturligtvis - att skapa "vitsordet" för en ordvits.


Här är några fler kombinationer, mer eller mindre slumpmässigt tagna ur luften. Visst urval har gjorts av de av programmet presenterade ordkombinationerna.

firefox + unix:
unirefox


doktor + ordinera (som Henrik Sundström har en skoj liten tävling kring):
doktordinera


socialdemokraterna + moderaterna:

mokraterna
modemokraterna
socialderaterna
socialdemoderaterna


randomisera + kjellerstrand
kjellerstrandomisera


Ajax
Programmet är alltså skrivet med Ajax-tekniken, så några ord om detta kanske kan vara på sin plats. Möjligen är det inte det bästa exemplet, men good enough är också bra.

Vanliga CGI-program (som jag ofta använder för mina privata program) laddar om sidan för varje gång man kör programmet och man måste skyffla en massa information varje gång. Ajax använder en annan metodik och hämtar data (t.ex. kör nödvändiga program) i bakgrunden, s.a.s sömlöst. Detta gör att man kan behålla information från sidan utan att skicka med en massa parametrar (vilket tenderar att bli ett härke och är helt enkelt trist). Bibehållandet av datan på samma sida symboliseras med räknaren av antalet sökningar, en JavaScript-variabel som uppdateras varje gång.

För att göra programmeringen lite enklare har här används Perls modul CGI::Ajax (f.d. perljax), men det är inte speciellt svårt att rulla en egen-variant för ett så simpelt program som detta (enkelt vad gäller data som ska skyfflas via webben, alltså) . Uppdatering: jag fixade ett av problemen genom att skriva en egen variant.

Notera att något är lurt i vissa webbläsare vad gäller den nationella tecknena (t.ex. "å", "'ä" och "ö").


Se även
Andra "useless" program av liknande slag.

Ajax Patterns, med Ajax-ramverk i olika programspråk
googlering på "ajax programming vilket ger en massa träffar.


Uppdatering
Förutom problemet med de nationella tecknen har det rapporterats om att för vissa webbläsare "hänger det sig" när man skrivit in första ordet. Kollar på detta och återkommer...

Uppdatering 2 - återkomsten
Nu får i alla fall inte jag några problem med de nationella tecknen. Åtgärden var att i stället för att använda CGI::Ajax så skrev en egen variant av JavaScriptet istället för det färdiggenererade av Perl-modulen. Programmet nås nu på en något annorlunda adress än tidigare: Word Meld Simple.

Posted by hakank at 09:05 EM Posted to Program | Språk | Systemutveckling

oktober 24, 2005

Programspråket J: en kort reseskildring

Introduktion

Som en del kanske vet tycker jag programspråk är fascinerande och försöker följa rådet i boken The Pragmatic Programmer att lära mig ett nytt programspråk om året (helst ett nytt paradigm), vilket funkar ibland.

Ett programspråk som jag har kollat in tidigare men av olika skäl inte mer än ytligt är J som är en utveckling (utökning) av APL (som jag även kollat in men det kräver ett eget tangentbord med speciella tecken så det var inte så skoj). J har i princip samma konstruktioner, men man använder rena ASCII-tecken i stället.

De senaste veckorna har jag faktiskt lyckats lära mig en del av språket. Det följande är egensinnig introduktion av J och visar inte språkets alla styrkor; man bör snarare se det som en reseskildring av några av mina upptäckter i språket.


Kort om J


J är ett mycket kärnfullt (och kärvt) språk som väl än mer än Perl ser ut som line noise. Det tillhör programmeringsparadigmen funktionella språken (ungefär som Haskell, Scheme, Lisp och liknande) samt de s.k. vektorspråken såsom Matlab, GNU Octave och R (ett av mina favoritspråk).

Det som är speciellt med J är dess arv från APL, nämligen att det finns många färdiga funktioner och dessa är definerade med ett eller ett fåtal tecken. Det gör att man inte behöver skriva långa avhandlingar för att skapa ett program. Såtillvida är det ett VHLL (Very High Level Language) såsom Perl, Ruby och Python, samtliga mycket trevliga programspråk. Man kan också notera att J är, liksom de tre nämnda språket, ett interpreterande språk (scriptspråk, eller som det nu bör kallas pragmatiska eller agila programspråk). Och det är en stor poäng eftersom språket inbjuder till att sitta och leka vid prompten eller i GUI:t.


Några installationskommentarer


* Program till Linux, Windows och Mac finns att hämta hos Jsoftware.
* Mer information såsom dokumentation om språket och systemet finns i Se även-avsnittet nedan.


Program / funktioner


Låt oss ta några exempel på saker som har skrivits här eller annorstädes den senaste tiden. När jag lär mig nya programspråk finns det en del standardexempel som alltid implementeras, t.ex. konkordanstabeller, läsa in filer för att matcha med reguljära uttryck, skapa hashtabeller etc. Några av dessa standardexempel beskrivs även här nedan.

Text i fetstil anger resultatet av en operation. Nota bene: NB. anger en kommentar.


Summan av 7 första primtalen = 666


Henrik Sundström glada upptäckt att summan av kvadraten på de första 7 primtalen är 666 skrivs så här i J.


p: i. 7
2 3 5 7 11 13 17

(p: i. 7)^2
4 9 25 49 121 169 289

+/ (p: i. 7)^2
666

Förklaring:

p: skapar det i:te primtalet.
i. n genererar talen 0 .. (n-1).
^ är naturligtvis "upphöjt till"
+/ gör en summering av samtliga tal i listan, där / anger att man ska göra något (här summera) över alla element i listan och reducera till ett enda tal. (Mer tekniskt lägger / till "+" mellan samtliga element i listan. Det kallas för "insert".)


Om man nu vill testa om det finns flera roliga sådana tal kan man göra en "running sum", med +/\. Det verkar dock inte finnas några fler roliga sådana tal. I alla fall inte bland de första 20 primtalen.


+/\ (p: i.20x)^2
4 13 38 87 208 377 666 1027 1556 2397 3358 4727 6408 8257 10466 13275 16756 20477 24966 30007

NB. Ladda in liten färdiga rutiner, t.ex. diff
load 'strings regex misc files'

diff +/\ (p: i.20x)^2
9 25 49 121 169 289 361 529 841 961 1369 1681 1849 2209 2809 3481 3721 4489 5041


Man kan notera att allt inte är konstiga symboler och om det är för förvirrande kan man definera symbolerna till namn. Tack och lov finns det många färdigdefinierade funktioner lätt åtkomliga, t.ex. diff som i exemplet ovan, som ger differensen mellan två närstående tal i listan.


Jämförelse med naturliga språk


Något som är speciellt utmärkande för J (och APL) är att man i dokumentationen presenterar idiom, fraser (phrases) som man som utvecklare bör lära sig att känna igen. Vilket nog är nödvändigt eftersom det annars är svårt att lära sig språket. Jämför med hur man lär sig naturliga språk: I början lär man sig ord och mindre fraser, varpå man sedan lär sig mer komplicerad grammatik och skapar fullständiga meningar etc.

Jämförelsen med naturliga språk är också något som genomsyrar hela J. I stället för funktioner pratar man om verb, variabler är substantiv (noun) etc. Denna fokusering på naturliga språk har även fått mig att fundera på hur jag just nu lär mig J och i förlängningen hur man lär sig programspråk. Jag använder dock termerna från den vanliga programmeringsvokabulären här nedan.

Man kan även tänka på hur barn lär sig språk: genom att leka med orden och språket för att se om det blir något av denna lek. Detta lekfulla angreppssätt känns naturligt i J, och är till viss del nödvändig eftersom dokumentationen kan vara rätt kärv emellanåt.


Språknära exempel


Eftersom mina intressen är både tal och språk har jag lekt lite med mer språknära problem, t.ex. fördelning av bokstäver i ord. Låt oss ta ett enkelt exempel.


NB. En tilldelning av en sträng till variabeln str
str =: 'hakan kjellerstrand'

NB. Skapar antal tecken som finns för respektive position i ordet.
NB. Dvs 'h' finns 1 gång, 'a' finns 3 gånger, liksom 'k' etc,
+/"1 = str
1 3 2 2 1 1 2 2 2 1 1 1

NB. Ordningen vilket bokstäverna i ovanstående listas
NB. visas får med "nub", dvs de unika bokstäverna
~. str
hakn jelrstd

NB. Och om man av någon anledning vill veta i vilken position en bokstav börjar i kan man
NB. använda följande funktion:
char_pos =:((>:&# @ ~. @ ]) - (+/ @ (+/\ @ (=@ ]))))
char_pos str
1 2 3 2 4 3 5 3 6 7 8 8 7 9 10 11 9 2 4 12

Det där med line noise är kanske inte så långt ifrån...



Thebes talmagi


Ett annat aktuellt exempel. I Thebes Gåta (i kommentarerna) gjorde följande talmagiska konstruktion: B A C H -> 2 1 3 8 (dvs Bach).

Uppdrag: Skapa ett program för en sådan konvertering.


alpha=: 'abcdefghijklmnopqrstuvxyzåäö0123456789'
str =: 'bach'

NB. Själva konverteringen.
NB. # ger antalet element i listan
NB. =/ matchar tecken för tecken
NB. :| transonerar vektorn
NB. , gör det till en fin lista
,(|:(alpha =/ str)) # (>:i.38)
2 1 3 8


NB. Som explicit definition:
convert=: 3 : 0
(,(|:('abcdefghijklmnopqrstuvxyzåäö0123456789' =/ y.)) # (>:i.38))
)

NB. Detta kan även skrivas på en rad där man använder strängdefinition
NB. convert=: 3 : '(,(|:(''abcdefghijklmnopqrstuvxyzåäö0123456789'' =/ y.)) # (>:i.38))'

convert 'bach'
2 1 3 8


Thebe-tvärsumma


Som en klo på kvällens kräfta skapar vi även "Thebe-tvärsumman".


NB. Tvärsumman från 'bach' definieras på följande sätt.
NB. +/ känner vi igenom från ovan, nämligen summan av talen i listan
+/ (,(|:(alpha =/ 'bach')) # (>:i.#alpha))
14


NB. Definition av tvärsumma mer generellt
NB. Not: argumentet är ett tal och endast ett tal
digit_sum =: 3 : '+/ > ". &. > ;/ ":y.'

NB. Den reducerade tvärsumman
NB. Argument är _ett_ tal
NB. Notera att det även finns vanliga programkonstruktioner såsom while. ... do. .. end.
reduced_digit_sum =: 3 : 0
tmp =. y.
while. tmp > 9 do.
tmp =. digit_sum tmp
end.
tmp
)

NB. Test av detta:
7+7+7
21

digit_sum 777
21

reduced_digit_sum 777
3


NB. Och ett mer fullständigt exempel:
> (digit_sum t); (reduced_digit_sum t); [t =: +/ convert 'hakan kjellerstrand'
7 7 215


Augusti-pyssel


I Augusti-pyssel ställdes några pyssel. Svaren finns i Svaren på Augusti-pyssel och jag följer de lösningar som finns där.


1) Vad står här egentligen och varför (dvs enligt vilken metod): 1045668080
[Not: Det bör finnas en bättre och mer generell metod för detta, speciellt eftersom man här måste leta fram antalet 36:or. Troligen kan man göra det med en loop av divisioner med 36 eller liknande. Detta lämnas som en övning åt läsaren eller skrivaren.]


NB. b #: n är talet n i bas b
NB. n # y innebär att en lista av n stycken y
alphanum =: '0123456789abcdefghijklmnopqrstuvwyxyz'
((6 # 36) #: 1045668080 ) { alphanum
hakank


2) Vad står här egentligen och varför: 15604225

alpha =: 'abcdefghijklmnopqrstuvwyxyz'
q: 15604225
5 5 7 13 19 19 19

NB. Men J är 0-baserat, dvs "a" finns i position 0, "e" i position 4 etc så vi
NB. minskar med 1, vilket är precis det som <: gör.
<: q: 15604225
4 4 6 12 18 18 18

NB. Bokstäverna för respektive index
(<: q: 15604225) { alpha
eegmsss


Fråga 3
Denna fråga bestod av flera delar.

...., 1596, ?
Det är alltså summan av de första n Fibonacci-talen

NB. Definiera Fibonaccifunktionen
NB. (Det finns fler varianter på
NB. http://en.wikipedia.org/wiki/Fibonacci_number_program#J_examples )
fib=: 3 : '{. +/\@|.^:y. 0 1x'

NB. De första 15 Fibonaccitalen
> fib each >:i.15
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610

N.B. Listan av summeringen av de första 16 talen
+/\ > fib each >:i.16
1 2 4 7 12 20 33 54 88 143 232 376 609 986 1596 2583


3 b) ...., 78, ?
Summan av de 12 första naturliga talen

+/ >:i.11
66

+/\ >:i.11
1 3 6 10 15 21 28 36 45 55 66

+/ >:i.12
78

+/\ >:i.12
1 3 6 10 15 21 28 36 45 55 66 78

3 c) ...., 129, ?
Summan av de första primtalen.


N.B. De första 10 primtalen
p: i.10
2 3 5 7 11 13 17 19 23 29

+/ p: i.11
160

+/\ p: i.11
2 5 10 17 28 41 58 77 100 129 160


Simulering


Ett stort skäl till att jag började med J var att det verkar finnas bra stöd för simulering där jag tidigare främst använt statistikpaketet R, som ju också har en kärv syntax. Se t.ex. Kort om R och simulering - ett praktikfall.

Jag har inte suttit med detta så mycket i J, men några trevliga saker finns.

NB. Slå en tärning 10 gånger
NB. ? innebär randomisering
NB. >: öka talen i listan med 1
>: ? 10 $ 6
6 4 2 4 3 2 2 4 5 5

Låt oss se i vilken position 1:an kommer i en slumpmässig permutation (dragning utan återläggning) av 20 tal.

]x =: >:?~ # i.10
8 7 9 1 6 10 4 2 3 5

NB. Positionen av 1:an i en lista visas med boolean (0 = falsk, 1 = sann)
NB. (om programmet är korrekt ska det ju bli det fjärde talet).
(1 = x)
0 0 0 1 0 0 0 0 0 0

NB. Här räknar vi ut vilken position detta är.
NB. Notera att J är 0-baserad, så vi får lägga till 1 (>:)
NB. För att få bas 1-positionen
>: (1 = x) # i.#x
4

NB. Detta som en oneliner på en annan slumpad lista
>: (1= x=:>:?~ 10) # i.10
9

NB. Och här visas den slumpade listan
x
4 3 10 9 8 6 7 2 1 5

NB. Här är 20 sådana körningar i en lista, dvs positionen av talet 1.
,(1= x=: >:?~ 20 $ 10) # >:i.10
1 9 4 2 4 3 2 10 6 4 9 1 10 1 8 8 10 5 2 8


Jag kommer troligen att återkomma med simuleringar i J. På ett eller annat sätt.


Fler språkligheter


Jag tänker avsluta med några andra språkligheter, utan egentliga kommentarer.
Låt oss anta att vi har följande namn i en fil som heter words (för det har vi):


kalle
nisse
pelle
anna
olle
eva
paula
ulla
abcd



NB. Läs in filen till variabeln words
NB. ('b' innebär att man läser in filen som en "boxed vector"
words =: 'b' fread 'words'

NB. Längden för respektive ord:
> #&.> words
5 5 5 4 4 3 5 4 4

NB. Sortera respektive ord
words /:&. > words

+-----+-----+-----+----+----+---+-----+----+----+
|aekll|einss|eellp|aann|ello|aev|aalpu|allu|abcd|
+-----+-----+-----+----+----+---+-----+----+----+

NB. Vilka av dessa ord har bokstäver i bokstavsordning?
NB. Booleanlistan visar att det är det sista ordet.
words = (words /:&. > words)
0 0 0 0 0 0 0 0 1

NB. Vilket är det sista ordet, då?
> (words = (words /:&. > words)) # words
abcd

NB. Om man kör detta på en av mina vanliga ordlistor på 391084 ord
NB. blir det 533 träffar, däribland följande (någor redigerat)
abbot abbé abc aber abort abé accent accept access accis ack ad adel adeln adelns adels adelsö adeps adept adjö af affin affint affix ....

NB. Jag gjorde en timing av inläsning av den stora ordlistan.
NB. Det tar alltså cirka 0.8 sekunder.
timer=: 6!:2

NB. ] är argumentet
sorted =: (] = (] /:&. > ])) # ]

NB. Läs in filen
words=:'b' fread 'sv_spelling_org.txt'

timer 'sorted words'
0.853685


Reguljära uttryck


Som ytterligare exempel: Vilka ord finns det i ordlistan som innehåller bokstavskombinationen a...b...c...d . För detta använder jag en an mina favoritkonstruktioner, nämligen reguljära uttryck (regular expressions, regex). För att använda detta måste man - som jag förstått hittills - läsa in ordlistan som en stor fet sträng.

load 'regex' NB. Ladda regex-paketet

words2 =: 's' fread 'sv_spelling_org.txt' NB. 's': läs in som sträng

NB. Inledande och avslutande ".*" är för att hela ordet ska
NB. komma med i matchningen
matched =: '.*a.+b.+c.+d.*' rxmatches words2

NB. Hur många ord matchade?
#matched
31

NB. Vilka ord var det?
> , matched rxfrom words2

arbetsblockad
arbetscykeltid
arbetscylinder
arbetsprocedur
arboricid
auxinherbicid
avbackningsanordning
avbackningsdon
avblockningskondensator
bakåtblickande
epiduralblockad
framåtblickande
halvbackskedja
handelsblockad
handelsblockaden
handelsblockadens
handelsblockader
handelsblockaderna
handelsblockadernas
handelsblockaders
handelsblockads
hårdmetallbestyckad
kalibercylinder
kalibreringscylinder
parabolarbetscylinder
paracervikalblockad
raketbestyckad
samarbetsprocedur
sambandsprocedur
snabbtryckande
tillbakablickande


Tacita definitioner


En sak som jag fortfarande har lite svårt för är att skapa "rena funktioner", "tacit definitions", dvs där man bara skriver funktioner utan några parametrar. Sådana definitioner beskrivs också som något som kommer senare vid inlärningen av språket.

Standardexemplet är medelvärde:

NB. Den tacita, implicita, definitionen
mean =: +/ % #
mean (i.10)^2
28.5

NB. Motsvarande explicita, dvs som kräver ett argument (y)
y=: (i.10)^2
+/y % # y
28.5

NB. ... eller något kärvare. Notera att tilldelning görs inne i funktionen.
+/y % # y=: ((i.10)^2)
28.5

NB. Tack och lov kan man definiera funktioner "imperativt",
NB. där y. motsvarar höger argument
mean2 =: 3 : '+/y. % # y.'

mean2 (i.10)^2
28.5

Slutord

Ovanstående exempel är från sådant jag själv tenderar att sitta och leka med. J används för betydligt mer avancerade matematiska saker, t.ex. linjär algebra, singular value decomposition etc. Man kan notera att det även finns stöd för DLL, grafik, socketprogrammering, MS Windows-anrop etc etc.

Det finns även ett GUI med onlinehjälp etc, men jag använder mestades kommandoradsvarianten. En stor fördel med GUI-versionen är att man kan köra Labs, dvs laborationer dels för att exemplifiera delar av språket och dels för att visa hur man löser vissa matematiska övningar i J.


Se även


Huvudsajten för J är alltså Jsoftware.
Innehållsförteckningen över dokumentation, böcker, artiklar etc: Documentation

För några dagar sedan ändrade man sajten till en Wiki så det inträffa att några länkar inte fungerar ännu.

De dokument/böcker som jag främst rekommenderar att läsa är följande:
* J Primer redogör för grunderna i språket.

* För en översikt över systemet, t.ex. installation och vilka paket som finns, är User manual oumbärlig, men där står inte så mycket om själva språket.

* Dictionary är referensen. Tyvär gjorde jag misstaget att börja med denna bok, vilket inte var så bra eftersom förklaringarna inte är för nybörjare. Det är mycket bättre att börja med J Primer.

* För erfarna programmerare kan även rekommenderas J for C programmers som har bra tips om debugging och liknande. Finns även som zippad PDF.

Det finns ett flertal böcker som beskriver hur man programmerar i J inom olika matematiska områden. Se avdelningen Books.

* Glöm inte bort mailinglistan jforum. Deltagarna verkar vara mestadels trevliga och tillmötesgående. Ett arkiv finns här

NB. Delningen av mailinglistan i flera delar är något väldigt nytt, och alla har inte kommit igång ännu.


Något om historiken bakom J (och APL):
* Kenneth IversonA personal view of APL (PDF)
* Roger Hui om APL, J och Iverson

Andra läsvärda saker:
* Roger Hui: A Sudoku Solver. Programmet är snabbt men - understatmentvarning - inte helt enkelt att förstå.

* Olika versioner av Fibonacci-definitioner wikipedia

* Fler länkar: Links.

* Tidskriften Vector, som handlar om APL, J och liknande språk.

Posted by hakank at 08:42 EM Posted to Systemutveckling | Comments (10)

augusti 22, 2005

IT Conversations: Stephen Wolfram

IT Conversations: Stephen Wolfram

For three centuries scientists have looked to mathematics to understand how nature works -- and to create the foundations for technology. But based on his surprising discoveries about simple computer programs, Wolfram, creator of Mathematica and author of A New Kind of Science, has developed a radically new approach. Stephen Wolfram not only addresses many fundamental questions about science and the universe, but also suggests major new directions for technology.
...

Se även
Stephen Wolfram
A New Kind of Science (Bokus, ISBN: 1579550088), som jag köpte för nästan exakt två år sedan, men har ännu inte läst hela
A New Kind of Science Online
Andra böcker av Wolfram (Bokus-länk)
Mathematica.


P.S. IT Conversations har ett gäng RSS-flöden.

Posted by hakank at 05:11 EM Posted to Komplexitet/emergens | Matematik | Systemutveckling | Comments (3)

augusti 16, 2005

Analogi mellan skrivandet av Harry Potter och utveckling av programspråk

Guido van Rossum, grundaren av det trevliga programspråket Python, gör en kort och kärnfull analogi mellan utveckling av programspråk och skrivandet av Harry Potter. (Egentligen gäller detta vilka bok-/film/TV-serier som helst, men Harry Potter är ett namn som slår just nu.)

Från The Harry Potter Theory of Programming Language Design

I'm sure that when J.K. Rowling wrote the first Harry Potter book (planning it as the first of a series of seven) she had developed a fairly good idea of what kind of things might eventually happen in the series, but she didn't have the complete plot lines for the remaining books worked out, nor did she have every detail decided of how magic works in her world. ... Just like the successive Harry Potter books are required to have "continuity" (we can't have Dumbledore's taste in sweets change drastically in book 3), successive versions of Python are constrained by pretty serious backwards compatibility requirements.

Sometimes it's easy to go back and generalize a feature; for example, the transformation of built-in conversion functions like int(), str() and list() into built-in classes feels like a stroke of genius (if I may say so myself :-). On the other hand, the recent discussion on python-dev of the exception hierarchy, summarized in PEP 348, shows that early choices sometimes are less than ideal, even if they're not fatally flawed. The mismatch of naming conventions and API quality in the standard library is another example.

Posted by hakank at 05:56 EM Posted to Systemutveckling

juni 14, 2005

Peter Lindbergs reboot7-föreläsning: The Three Pillars of Software Architecture

Egentligen heter Peter Lindbergs reboot7-föreläsning The Social/Psychological Side of Software Architecture men The Three Pillars of Software Architecture är en mycket fräckare titel.

[M]uch of software architecture today is about technology. But technology is only one of three pillars of software architecture. The other two concern the human things. They concern the social and the psychological. Collaboration and thinking. Groups and individuals.

Förutom många intressanta insikter i systemutveckling innehåller föreläsningen flera spännande boktips.

Se även t.ex. Peters tidigare Min Statskontoret-rapport om IT-arkitektur.


(Not: Det är något kinkigt med Reboot-länken just nu.)


Uppdatering
Föreläsningen finns som ljudfil här (MP4, 33Mb). Andra upptagningar finns på archive.org. Denna information kom via Erik Stattin.

Posted by hakank at 07:29 EM Posted to Systemutveckling

maj 01, 2005

The long tail of programming languages

Charles Simonyis (Intentional Software) skriver i The long tail of programming languages om att användningen av programspråk förhåller sig till varandra som en long tail (cf power laws). Man har använt statistiken från TIOBE Programming Community Index for April 2005 (se kommentar nedan).

Vilka slutsatser drar man så av denna långa svans?
* Generella programspråk tenderar av användas mest eftersom de är generella (vilket ju verkar rimligt)

* Det finns språk som ofta är bättre än generella att lösa problem i en specifik domän (nischen), t.ex. Prolog för logikprogrammering.

* Det är svårt för nya programspråk att lyckas slå igenom ordentligt eftersom det krävs bra miljöer för professionell utveckling.


Här är några reflexioner angående detta.

Förutom dessa mer rationella skäl finns det andra saker som gör att användningen fluktuerar. T.ex. Ruby:s Ruby on rails har gjort att fler har fått upp ögonen för Ruby; Pugs som är en trevlig Perl 6-implementation skriven i Haskell - som redan efter några månaders utveckling fungerar förvånansvärt bra - har gjort att Perl-användare blivit intresserade av Haskell och säkerligen också föranlett ett nyuppväckt intresse för Perl. Hmm, kan det vara detta som är orsaken till Perls ökning?

När det gäller TIOBE-jämförelsen av programspråk bör man notera att man studerar hur ofta ett språk nämns. Från sajten: The popular search engines Google, MSN, and Yahoo! are used to calculate the ratings. Observe that the TPC index is not about the best programming language or the language in which most lines of code have been written.

Med denna stora brasklapp i A4-format på skrivbordet kan man notera att omnämningen (användningen?) av C++ och Java har minskat jämfört med förra året. Lennart Frantzell kommenterade i Är Java-språket på fallrepet?, såvitt jag kan se utan referens till denna undersökning (varken direkt eller indirekt). Så här får han lite mer vatten på sin kvarn.

[Det skulle f.ö. vara intressant med en undersökning som studerar hur förändringar i omnämnande av ett programspråk är kopplat till förändringar av dess användningen. Troligen är det här skillnad i förändringsstruktur mellan "professionellt" användande och "privat" användande där förändringar i "professionellt" användande har dels större tröghet och dels andra krav på ett programspråk än privat utveckling. Gränsen mellan dessa två håller dock på att försvinna mer och mer i och med open source-projekten.]


En sista kommentar. I artikeln står det Many developers who must use Java or C# at work during the day go home to use Ruby or Python on their personal projects at night.

Man kan nu börja hoppas på att programspråksmoneteismen ("jag tror på ett enda programspråk och det är min gud") håller på att försvinna och att vi till slut inser att olika programspråk har olika fördelar i olika situationer/domäner.

Det är inte meningen att här starta något religionskrig om programspråk, speciellt eftersom jag numera är programspråksagnostiker (eller möjligen programspråkstaoist). Av bl.a. historiska och repositoriska skäl har jag naturligtvis ett par favoriter men kollar gärna in både nya och gamla programspråk. I går hittades t.ex. en referens till ett språk som heter Fornax (från 1994) som verkar intressant eftersom det kombinerar flera av mina favoritsyntaktiska socker; tyvärr hittades inte någon implementation.

Ingången till denna anteckning var Lambda the Ultimate:s The long tail of programming languages, vilken också bör läsas.

Posted by hakank at 10:05 FM Posted to Komplexitet/emergens | Statistik/data-analys | Systemutveckling

mars 15, 2005

NPR-intervju med Donald Knuth

NPR : Donald Knuth, Founding Artist of Computer Science

Posted by hakank at 05:23 EM Posted to Systemutveckling

december 17, 2004

Mer om SwarmStream och BitTorrent

Apropå SwarmStream.

Från Coding in Paradise: Coding In Paradise: Why BitTorrent is Important and SwarmStream is Doomed

Overview:
1. How Useful is Swarming and the Onion Networks SwarmStreaming Product?
2. What are the Potential Drawbacks of the SwarmStream Product?
3. Why BitTorrent is Important and SwarmStream is Doomed

Posted by hakank at 06:57 FM Posted to Systemutveckling

december 13, 2004

SwarmStream

Detta är något att kika vidare på.

Onion Networks SwarmStream presenteras i JavaLobby Expert Presentation: SwarmStream: WAN, Caching, and Swarming for Java.

Presentatören säger bl.a. (fast på engelska då och kanske inte riktigt så familjärt) "om du är imponerad av Bittorrent kommer du fullständigt flippa ut när du kikar på SwarmStream".

Så här beskrivs SDK:n: The SwarmStream SDK is a comprehensive suite of acceleration technologies that greatly enhance the raw speed and reliability, of enterprise, consumer, and military applications over Wide-Area Networks. Onion Networks redefines state-of-the-art by being the first company to provide WAN Acceleration, Caching, Random Access Acceleration, Self-Healing Data Transfer, and Grid Acceleration all in a single, easy to integrate package. From downloadable movies to enormous CAD files to XML messages, only SwarmStream provides the reliable and dependable performance needed for today's networked applications.

Swarmingtekniken förklaras lite mer här.


Om inte annat så kan rekommenderas att leka med en simulering: Swarming Content Delivery Simulation (f.ö. gjord i RePast Agent Simulation Toolkit).

Uppdatering
New Scientist skriver om SwarmStream i Data swarms to speed net streaming

Posted by hakank at 07:42 EM Posted to Systemutveckling

november 29, 2004

Peter Lindbergs Statskontoret-rapport om IT-arkitektur

Peter Lindberg skriver i Min Statskontoret-rapport om IT-arkitektur om en rapport angående IT-arkitekturens historik och utveckling som han gjort åt Statskontoret, där han försöker bland annat utreda kopplingarna mellan byggnadskonst och stadsplanering och IT-arkitektur.

Rapporten heter IT-ARKITEKTUR Konsten att beskriva visioner för IT-relaterade förändringsarbeten (PDF).

Från inledningen:
Föreliggande rapport har utarbetats som ett bakgrundsmaterial till Statskontorets rapport Den offentliga förvaltningen i e-samhället (2004:27), som är ett diskussionsunderlag om en arkitektur för en modern nätverksförvaltning. Diskussionsunderlagets utgångspunkt är att det behövs en vägledande förvaltningsarkitektur; dvs. en övergripande beskrivning av den struktur och de processer som den svenska förvaltningsutvecklingen bör syfta till.
...
IT-arkitektur är alltså konsten att beskriva visioner för IT-relaterade förändringsarbeten. God IT-arkitektur är således den som lyckas förmedla en vision till de som berörs av den, så att dessa har en så samstämmig bild som möjligt av vad som är målet med förändringsarbetet.


Läs rapporten, den är mycket trevlig.

Posted by hakank at 07:12 EM Posted to Systemutveckling | Comments (2)

juli 29, 2004

Semantic Web i fara?

Simon Winter på Infontology skriver en intressant analys av Semantic Web och bakgrunden till de kritiska rösterna om projektet.

Läs vidare i hans Semantic web-programmerare vill ha time out som börjar på följande sätt:
Jag har försökt följa utvecklingen av den semantiska webben (semantic web) ett tag, och frapperats av hur lite motstånd det har funnits mot den objektivistiska semantik som hela projektet bygger på.

Posted by hakank at 11:46 EM Posted to Systemutveckling

juni 25, 2004

Jochen Fromm om Agent Oriented Software Engineering

Jochen Fromm beskriver i Agents, Roles and AOSE sina åsikter om vad agentorienterad systemutveckling kan och inte kan.

Does Agent Oriented Software Engineering (AOSE) make sense ? Yes, under certain conditions, but for a normal software developer and programmer familiar with object-oriented programming, the name is perhaps a bit misleading.
...
Agent Oriented Software Engineering (AOSE) makes no sense for closed standard software systems or if you use free, unlimited and unconstrained agents, pure agents without rules and roles. AOSE makes more sense for open applications in a complex unpredictable environment and if you are assigning "roles" to each agent.


Se även blogganteckningen Jochen Fromm: The Emergence of Complexity.

Posted by hakank at 08:11 FM Posted to Systemutveckling

juni 09, 2004

Jämförelser mellan agila programspråk (och andra)

Scriptometer innehåller en intressant jämförelse mellan (främst) olika skriptspråk såsom Perl, Python, Ruby och Icon. [Dessa språk kallas även för Very High Level Language (VHLL), scripting languages, script-oriented languages, och numera tydligen också "agila språk", se t.ex "Python is an Agile programming language".]

Här är några andra programspråkjämförelser:
Lutz Prechelt: An empirical comparison of C, C++, Java, Perl, Python, Rexx, and Tcl for a search/string-processing program

The Great Computer Language Shootout (inte uppdaterad på flera år)
Hittade senare: The Great Computer Language Shootout (ny uppdaterad version av föregående)
PLEAC Programming Language Examples Alike Cookbook, där man försöker att skapa kod motsvarande The Perl Cookbook för en massa andra programspråk.
Cameron Laird's personal notes on language comparisons

Se även Pixel's language Study där Scriptometersidan finns.

Posted by hakank at 08:25 EM Posted to Systemutveckling | Comments (2)

How an idea becomes a C# language feature?

How an idea becomes a C# language feature?.

(Via Lambda the Ultimate.)

Posted by hakank at 07:41 EM Posted to Systemutveckling | Comments (2)

februari 04, 2004

The Selfish Class

The Selfish Class (PDF) skriven av Brian Foote och Joseph Yoder beskriver varför viss kod "överlever" med utgångspunkt i darwinistiska teorier. Titeln alluderar till Richard Dawkins bok The Selfish Gene.

Ett tack till Peter Lindberg för peket till artikeln. Han skrev en notis om den anno 2002.


Abstract:
This paper takes a code’s-eye view of software reuse and evolution. A code-level artifact must be able to attract programmers in order to survive and flourish. The paper addresses the question of what an object might do to encourage programmers to (re-)use it, as opposed to using some other object, or building new ones. THE SELFISH CLASS pattern shows how focusing on code, rather than systems, processes, or personnel, can lead to fresh insights into software evolution and the forces that drive it.

The remaining patterns focus on more specific problems that evolving artifacts might confront. A software artifact that WORKS OUT OF THE BOX provides enough defaults to get the user up and running without needing to know anything about the artifact. An artifact that presents a LOW SURFACE-TO-VOLUME RATIO exposes its services via a relatively compact external interface, while encapsulating significant internal complexity. GENTLE LEARNING CURVE observes that artifacts that don’t pose an undue learning burden on beginners can win users, while revealing additional complexity later. PROGRAMMING-BY-DIFFERENCE shows how code can adapt without mutating. FIRST ONE’S FREE suggests that giving your code away will help to make it popular. WINNING TEAM suggests that you can ride the coattails of a winning system to victory.


Den undersökning som skrevs om i Undersökning av Java-system för agentbaserad modellering skulle kunna ses som ett exempel på analys för att utröna överlevnadsvärdet hos de studerade systemen.

Posted by hakank at 08:43 EM Posted to Komplexitet/emergens | Systemutveckling

januari 20, 2004

"Begreppsprogrammering"

På Lambda the Ultimate pågår en diskussion om Concept Programming. De flesta i debatten är tämligen kritiska, kanske inte så mycket till principen - som några menar är att slå in öppna dörrar - utan mer till att författaren inte riktigt lyckas förklara vad han menar.

Men visst låter detta bra (från Concept Programming-sajten; emfas i originalet):
Concept programming is initially a very simple idea: Your code should reflect the concepts in your application.
...
A concept is something from the application environment that matters to your program. A "window" displaying some information may be a concept. Most algorithms are derived from some mathematical concept. A "function" may be a concept. Programming is the art of turning concepts into code.

Se även Slashdot-diskussion från 2002.

Posted by hakank at 07:13 EM Posted to Systemutveckling

december 12, 2003

Groovy - uppdatering

För några veckor skrev jag om programspråket Groovy. Följande sägs på lite olika ställen på Groovy-sajten: Groovy's initial niche is scripting, constructing and testing Java objects.

När jag skrev förra gången var språket i experimentstatidiet och hade en del brister. Den största bristen var enligt min mening att man var tvungen att skriva egna drivers i Java och att vissa konstruktioner inte fungerade, såsom exemplet nedan. I version 1.0-beta, som nyss kommit ut, är detta fixat så det fungerar nu som ett riktigt scriptspråk. Ladda ner den härifrån.

Här är ett exempel som faktiskt fungerar: 
class Foo {
  doSomething() {
    data = ["name": "James", "location": "London"]
    for (e in data) {
      println("property ${e.key} is ${e.value}")
    }
  }
  
  closureExample(collection) {
    collection.each { println("value ${it}") }
  }
  
  static void main(args) {
   values = [1, 2, 3, "abc"]
   Foo foo = new Foo()
   foo.closureExample(values)
   foo.doSomething()
  }
}
Om man sparar detta i filen Foo.groovy, kör man med kommandot 
groovy Foo.groovy
och får, inte helt oväntat, följande resultat: 
value 1
value 2
value 3
value abc
property location is London
property name is James
Det går också att kompilera till en .class-fil och anropa från egen Java-kod.

För mer information se:
Groovy (sajten)
Quick Start Guide to Groovy.
Overview
Presentation: Groovy - Making Java more funky som också innehåller en del exempel.


Se även Groovy 1.0-beta-1 is out! från James Strachan's Radio Weblog samt First Release for Groovy 1.0: JVM Scripting Language från TheServerSide.com.

Posted by hakank at 07:53 EM Posted to Systemutveckling

oktober 15, 2003

Design och magi

Tog har en intressant jämförelse mellan magiker och design. Dölj det komplexa för användaren.

Från Web wizards weave their magic:

Former Apple veteran Bruce "Tog" Tognazzini argues that the secrets of successful websites are the same as those of successful magicians.

Now with the usability consultancy firm, the Nielsen Norman Group, Tog has been looking at how people interact with their computers and the net.

He has found a surprising number of similarities between magic and web design.

"Both are based on illusion and misdirection, making us believe something which is not real and doesn't actually exist," he says.
...
Much of it revolves around simulation and dissimulation. Magicians do this all the time, making someone believe something which is not actually happening.
...
"Keep it useful, keep it swift and then add showmanship," Tog advises any would-be web wizards.

Posted by hakank at 03:23 EM Posted to Systemutveckling | Comments (1)

augusti 30, 2003

Silvertejp

Silvertejp är ett intressant projekt som väl kortfattat kan summeras som en kodgenerator för UML klassdiagram skriven i ASCII. Det är skrivet av en kreativ svensk kille vid namn Karl Wettin.

Som det står på sajten:

Silvertejp is a pre-processor language. It combines UML class diagrams with the object oriented programming language (pl) of your choise. It translates class diagrams to the destination pl of your choise.

Silvertejp uses an ASCII notation that allows you to blend source code with the class diagram, supporting almost all UML-elements defined in the class diagram meta-modell version 1.4 from the Object Management Group).

Java is currently the only supported pl, but it would be a peice of cake for any cross/java programmer to make it support Python, Smalltalk, C# et.c.

En liten demonstration av systemet görs här, och kan hämtas hem från Sourceforge här.

Posted by hakank at 03:09 EM Posted to Systemutveckling

augusti 20, 2003

Metaforer och systemutveckling

Jag rekommenderar en läsning av Peter Lindbergs utmärkta summering (eller inramande) av sin syn på metaforer och systemutveckling.

Den gjorde så att i alla fall jag fick en mycket klarare syn på hans rikliga tankeproduktion och jag ser nu bättre sambanden mellan hans olika intressen (som i många fall råkar sammanfalla med mina egna).

Detta är något att fundera vidare på.


En liten ostrukturerad tanke jag fick kring detta (och som nedan leder till andra associationer) var att det skulle vara fantastiskt att ha en hel virtuell värld som metafor. T.ex. inför ett projekt bestämmer man sig att Kafkas Processen är den "metaforgenerator" som ska användas inom projektet, dvs alla projektmedlemmar ska läsa boken minst en gång (nej, det blir inget prov på att man läst den :).

Det kan innebära att man som utgångpunkt för en diskussion kanske börjar med att fundera kring vad rättegången egentligen handlar om eller vilken frustration man själv skulle känna om man vore utsatt för samma händelsekedja, men sedan hamnar i en mer konkret diskussion om hur man ska lösa det där problemet att det är lång svarstid på programmet.

Låt oss kalla detta för RomanBaserad Utveckling.

En positiv bieffekt av detta är att vi tekniker tvingas att läsa annat än ren teknisk litteratur.


Det är lite samma sak som att ha Gudfadern som sin bibel, eller - som jag själv har upplevt i min post-tonårstid - som den bok vilken man relaterar olika verkliga situationer till. Mario Puzos underbara, snusförnuftiga och torra kommentarer om olika händelser i boken går direkt in i hjärtat, eller om det nu är hjärnan. För den delen är det så även med Kunderas böcker.

Från filmen You've got mail finns en relaterad dialog (som jag snott härifrån):

KATHLEEN: My business is in trouble. My mother would have something wise to say.

JOE: I'm a brilliant businessman. It's what I do best. What's your business?

KATHLEEN: No specifics, remember?

JOE: Minus specifics, it's hard to help. Except to say, go to the mattresses.

KATHLEEN: What?

JOE: It's from The Godfather. It means you have to go to war.

KATHLEEN: The Godfather? What is it with men and The Godfather?

JOE: The Godfather is the I Ching. The Godfather is the sum of all wisdom. The Godfather is the answer to any question. What should I pack for my summer vacation? "Leave the gun, take the cannoli." What day of the week is it? "Maunday, Tuesday, Thursday, Wednesday." And the answer to your question is "Go to the mattresses."
...


Kathleens bibel verkar vara Jane Austens "Pride and Prejudice", även om hon inte gör någon elegant analys som Joe om Gudfadern. Hennes kommentar om P&P är en liten pärla. Från Austen citing: You’ve Got Mail: Confession: I have read Pride and Prejudice about 200 times. I get lost in the language–words like thither, mischance, felicity. I’m always in agony over whether Elizabeth and Mr. Darcy are really going to get together. Read it – I know you’ll love it.

Joe tyckte inte alls om Pride and Prejudice och jag är osäker på om han egentligen läste ut boken, så det verkar som det skulle symbolisera en klyfta mellan två olika personligheter. Men nu råkar jag faktiskt tycka om både P&P och Gudfadern...

Posted by hakank at 02:30 EM Posted to Böcker | Filmer | Systemutveckling

juli 23, 2003

Komplexitet i mjukvaruarkitektur

I forskningsrapporten Hierarchical Small Worlds in Software Architecture används tekniker från teorin om komplexa nätverk för att undersöka komponentstrukturen i flera olika större utvecklingsprojekt. Man hittar - naturligtvis! - "small worlds-"effekter och skafria beteenden.

Abstract : The components of a large software application do not interact in random ways. Instead, class diagrams exhibit remarkable topological similarities to other natural and artificial systems. The components of a large software application are very well connected because the mean shortest distance between them is very low in spite of having a relatively small number of connections per class. In addition, these diagrams are very heterogeneous. These measurements are of a general nature and are largely independent of the particular semantics of the application. As shown in this paper, and irrespective of the specific features of each system analyzed, the final outcome of software evolution is a small world, hierarchical class diagram with well-defined statistical properties. The consequences for software evolution are outlined.

Från rapportens avslutande kommentarer: The important point of our work is that different software architectures share the same universal topological features, that is, small-worldness and scale-free behavior. This is a very surprising result and raises several interesting questions about how we (as human designers) organize knowledge and express the inner workings of a very complex, and abstract machine.

Posted by hakank at 10:27 EM Posted to Dynamiska system | Systemutveckling

juni 24, 2003

Komplexa system och software engineering

Detta är en kommentar till Peter Lindbergs artikel från 9 mars i år Software systems are complex systems. Se även hans artikel Network science and software från 8 maj. Peter vill bl.a. ha tips på lite nyare böcker om komplexa system, speciellt med inriktning mot software engineering.

Här är lite nyare (inköpta men icke lästa) böcker om komplexitet och liknande som kan vara intressanta:

Det Peter skriver om kopplingen till software engineering fick mig också att tänka på en del av teorierna i social network analysis. Några förflugna tankar:

Posted by hakank at 03:00 EM Posted to Dynamiska system | Komplexitet/emergens | Social Network Analysis/Complex Networks | Systemutveckling