1. If you haven’t, go install XCode from your retail disk or from the download at Apple’s developer connection.
2. Open terminal.app .
3. Go set up your shell variables. Somehow Go seems to prefer to be installed into the user’s home directory, but it can be installed system wide if you want. For now let’s just follow the official guide here.

Use your favorite editor to open ~/.profile, mine is nano.

nano ~/.profile

At the bottom part, you will have to add 4 entries, the rest of the variables will be assumed by the go compiler.

export GOROOT=$HOME/go
export GOARCH=amd64
export GOOS=darwin
export PATH=$HOME/bin:$PATH

Now save the file, in nano this is done by pressing ctrl-o.

4. Reload your profile.

source ~/.profile

5. Create the folder bin in your homedir, go will assume this by default. This can optionally be changed by setting GOBIN in your .profile .

mkdir $HOME/bin

6. Install mercurial, the versioning service hosting Go. When prompted type in your password, you are giving administrative access here.

sudo easy_install mercurial

7. Clone the repository to your local disk

hg clone -r https://go.googlecode.com/hg/ $GOROOT

8. Now change into the source dir.

cd $GOROOT/src

9. Install the Go tools by running the following command:

./all.bash

10. You are all done now.

You can now proceed to writing your first hello world applications, this is written in a short summary on the Installing Go page, section Writing Programs.

Simple HelloWorld.go:

package main

import fmt "fmt"

func main() {
	fmt.Printf("Hello world\n");
}

If you want you can ease up development using a more common folder structure and a Makefile. I usually keep the following folder structure:

. – Holds Makefile, AUTHORS, CHANGELOG, LICENSE, etc..
./src – holds all source files
./build – intermediate folder for build files (mainly for the linker)
./bin – the binary files
./dist – optional folder where releases are being created, usually by copying stuff from the bin folder.

You can use the following Makefile as a starter if you want.

# Simple make file for Google Go applications
# -----------------------------------
#
# Make sure you have your go installation set up correctly and 6g and 6l are working properly

COMPILER := 6g
CFLAGS :=
LINKER := 6l
LFLAGS :=

default: core

core:
	$(COMPILER) $(CFLAGS) -o build/HelloWorld.6 src/HelloWorld.go
	$(LINKER) $(LFLAGS) -o bin/HelloWorld build/HelloWorld.6

clean:
	rm -Rf build/*
	rm -Rf bin/*

Enjoy .

 
Modern times call for modern business, social networking is playing a huge part in that. There is a lot to learn about participating in this form of digital networking, yet there have been numerous articles on the net about all facets already. Social Networking for Business packs all this information in a single well written guide for your social networking project.

Many companies nowadays participate in social networks, some even base their core business around them. A few years ago there were not really full time jobs in this field, and the people managing a social group where doing it as a side job to their regular activities. This book aims to educate its reader in a broad range of activities, be it a foundation for a full time job, side activity or a long lasting project, it has you covered.
The author Rawn Shah draws from his experience as a manager for IBM and its DeveloperWorks communities and actively participating in the biggest players on the market.

The book’s sub-title “Choosing the right tools and resources to fit your needs” is accurately titled, because author doesn’t tell you to follow a specific path or mind set, but rather defines the possibilities and resources out there. Provided you take some time to study this book, you will be provided with an advantage over others aiming to get into this field. The well written style of the book provides a clear insight for which little info-graphics are needed. Most information is formatted into tables and just regular text with a little chart here and there. The eleven chapters really have got much information packed in them, and are presented in a logical order. The last two chapters of the book provided, at least for me, the most interesting information. These chapters talk about measuring social environments. The reason this chapter is so interesting, is that there is so much information you can measure to provide an idea about the impact of social networks and how they can earn you revenue. The author does explain very clearly what can and what can not be monitored, and that it’s hard to calculate a conversion ratio for this information.

Overall I think this book is a great asset to your personal education, and can help you really understand how to manage social communities from start to finish. I see how this book can give you the confidence to go into the position of community manager, but businesses are still learning what the word “social” means. The book gives you plenty of knowledge to justify a real management plan for your social projects. I think the publisher Wharton School Publishing really has yet another gem to their already huge collection of business related books.

Being a developer for a medium sized company where projects are led by lead developers, I already recommended this book to my peers, and will continue to do so in the future as this is the only book I know of that touches so much information in this field and it still manages to keep all this in just over 160 pages. It’s a quick read and I highly recommend it for almost all business professionals, ranging from technical leads to management when dealing with anything remotely related to social business.

Creating high performance growing networks is really a special skill managers and network architects should posses to be ready for the future. The Art of Scalability is a book written for these kinds of functions, and prepares you for the present and the imminent future. Scalability is achieved by principles that work on many levels within enterprises, wether it’s processes, organizational structure or setting up your project, this book covers it all.

The sub-title for this book is “Scalable Web Architecture, Processes and Organizations for the Modern Enterprise” which is basically a catchy title for project managers and decision makers. It’s just catchy enough to grab the book from a shelf and start digging into the table of contents, which is exactly the spot where you get hooked and decide to get the book.
The book is written by two experts on the subject; both of them have a strong background in large corporations dealing with scalability. Throughout the book the authors shine a good light on tools and cases used for making a project scalable.

The book is divided into four sections which follow the process of starting a scalable project. First off you will need to know everything about strategy, organizational structure, the kind of people your organization needs and how to manage your team.
The second part focuses on the how’s and why’s of scalability, aspects of planning for continuity, crisis and incident management. The later chapters in this second part talk about risks, how to value risk and the importance of testing to make educated conclusions about how far to scale your project, a notable mention here is chapter 19 which focuses on tradeoffs in development speed or doing things the right way, often an underestimated point in these businesses.
Architecting scalable solutions is the third part of the book, mainly taking a more technical approach to the matter. This part talks about containing faults and breaking up applications so they scale well. This goes all the way to scaling the database backend for your application to caching objects and making synchronous versus asynchronous calls to your application.
While most of the book is good for preparation, I think the fourth part of the book crosses the boundary from preparation to being very useful during the process as a fallback to your knowledge. It’s titled accordingly “Solving other issues and challenges” and mainly focuses on things you will come across during the first and perhaps even later stages, providing solutions for unforeseen costs of data storage to monitoring your application for user experience, speed and the processes you will have to implement for this.

If you have read this far, and are thinking about how complex scalability really is, then you have found the right book. The clear writing style and detailed writing of numerous pitfalls for such big projects make this book a valuable asset to your knowledge base. It’s also written in a challenging way, and between the lines there is also some humor (evident for instance in the reference to Rain Man in chapter 18), making it a fun way to learn or build upon a great skill set needed by organizations in the not so distant future.
I feel very positively about the writing style of the book, but despite there being some illustrations there could be some more diagrams of organizational structure and the architecture of projects as I didn’t find the illustrations adding much to the context.

The short appendixes to the book are mostly about calculating capacity for cpu power, bandwidth, etcetera. These appendixes actually provide sample calculations which are useful to backup your analysis when you need to make a bill of materials for your superiors and can also be used to better grasp the size of a project. Numbers mostly provide a context for the people above you, and I think these extra pieces of content could have deserved another part in the book, but perhaps it’s better off as some food for thought.

Before starting with this book, I had not much prior knowledge about scaling projects other then some technical ideas of implementation. I always hate it when I know I’m just scratching the surface of something, and need to satisfy my urge to learn more about the subject. The Art of Scalability really helped me accomplish that, and provided much more background information then I expected. I was really surprised by the pieces about cloud computing, it’s such a buzzword nowadays but the texts give it a real context.

If you are looking to set up a project or are generally interested by the concepts of scalability, then this is the right book for you. It’s an appropiate recommendation for most businesses, because this knowledge can only be used to your advantage and just takes a little bit of time to read trough. It’s a heavy subject, but once you finish the book you will be able to make a decision about architecture based on a good foundation of background information rooted in real situations.

The book is available on Safari Books online, the publishers portal Informit.com and other popular retailers.

Mod_maybe
A while ago I discovered mod_maybe, a module that mimicks the behaviour of Microsoft’s IIS webserver namely dropping connections and refusing to work at random.

As the author quite nicely puts it:
From a business point of view you need some clues, often, to demonstrate that a system is not reliable or it does not work properly. In these cases mod_maybe is what you are looking for. Since is not reliable by design, you can demonstrate pretty often how you server (running this module obviously), does not respond as Apache should.

Mod_pony
Started out as a joke but having made it into several presentations given by the author, mod_pony creates a nice sample module for whenever you need to use a “dummy” module. You could ofcourse use it for plain simple fun.

Mod_miserable
The tagline of this module quite sums it up Apache module for sadists. Mod_miserable is a module that inflicts misery upon a set range of visitors. Misery includes random showing of error messages, never sending back a response or triggering the all feared Internal Server Error. You could use this module quite similar to mod_maybe.

Lolcode output filters
While technically not being a module, this list can’t be complete without my lolcode filters for Apache. It’s a small set of filters running against tetraboy’s php parser.

So, whether you are a systems administrator with too much time on your hands, have a legitimate reason to use these modules or are just bored to death on a rainy day, you know what to do now. If you do find a legitimate reason for mod_pony, don’t hesitate to fill out my contact form at the bottom of this page to let me know.

For a long time now the web has been served by Apache’s webserver software, because the amount of servers and internet usage is still growing more and more important every day securing your server has become a task in the forefront of business. This book has been written to illustrate and educate you the ease of use and inner workings of the ModSecurity module for the most widespread webserver.

The cover reads “Prevent web application hacking with this easy-to-use guide” and sticks with this claim to provide you with a good pathway to secure your webserver. The book is aimed at system administrators ranging from enthusiasts running a webserver at home to your friendly administrators at a large company. Most of the book requires only familiarity with using the linux shell and basic Apache configurations, but earlier encounters with some technicalities like regular expressions may be of help during your reading period.

Throughout the chapters the author takes you from the different methods of installing ModSecurity and the basics of creating your first rules to the discovery and reporting of your possible intrusions. Generally providing solutions for example geolocating the origin of the hack, and automatically scanning uploaded files for viruses, the author Magnus Mischel proofs that his background in Internet Security makes his book a valuable asset to your bookshelf.
In the chapters found later in the book, the author shows how to use some commonly used tools to fingerprint your server and provides you with recipes on how to prevent these methods of gathering information about your server. There is also a lot of information about the impact of rules on the performance of your server. Because the impact is different in every situation, you will be guided around some tools to measure the performance and you will learn how to interpret this data.

Chapter 5 talks about Virtual Patching, a method of preventing misuse by intercepting bad traffic and creating a set of rules for this. This chapter is by far the best piece of information I have found on how this actually works, and how you implement such rules and configuration, and why you should use the method of virtual patching in your situation. Basically the author takes out all the question marks you will have about this method of quickly applying rules and provides a case which is fully illustrated with a lot of background information about the process of finding a insecure piece of code to solving this with a set of rules.

When Packt Publishing contacted me if I would like to review another book for them, I picked this one out of the new releases because using ModSecurity has never been a priority for me. After seeing the title and table of contents I realised that you can never start too early to dive into this subject, and start preventing misuse before it causes more trouble then you can handle, trouble always finds you at the worst times. The author has divided the book in logical chapters, and the depth of information builds up equally from beginning to end. For instance, the second chapter takes you trough the basics of regular expressions, but because you will encounter them during rule creation Appendix B will educate you with all specifics of creating those expressions.
As a developer running local test servers, I have found this book very interesting and a great resource on a for me grey area of server security. I am pleasantly surprised by the clarity of the book, the writing style makes you really want to dive into your webserver to apply your newly gained insight to ModSecurity.

The book has been written to provide the reader with a short introduction to the concepts of Service Oriented Architecture with Java. The book covers the theory and analysis from the start and is progressing to a more intermediate level slowly throughout the different chapters. This book has been written for software architects and programmers of the Java language who have an interest in building software using SOA concepts in their applications. The cover hints to a series called “From Technologies to Solutions”, and that is exactly what this book tries to do, it tries to explain the SOA technology with different case studies and a path for solutions for your applications.

When I ordered the copy of the book, I was under the impression that I was required some familiarity with terms used in the world of SOA but I was rather fond of the easy explanation of terms in the first chapter. The first chapter starts off with a small introduction to the role of software architecture when thinking about a software project. The chapter covers alternatives to SOA and tries to get the reader onto the right path for the rest of the book.

Later on in the book different subjects pass, the first few chapters start off with the basics of using XML as a communication layer. The third chapter introduces the audience to different implementations of web services in the Java world including the most familiar names as Apache Axis, Spring and XFire. The reader will be shown and guided to the install process of these web services and is being shown around the process of working with the software. The pros and cons of every piece of software are shown when following the steps throughout the chapters.

The book ends with chapters providing case studies of real world examples of SOA and alternatives. I have found this to be the most informative section of the book when looking to make decisions on how to architect a software project as it provides several examples on when to use which aspect of SOA. The different case studies allow you to put some weight and foundations into your decisions. The last chapter of the book is basically a conclusion of what we have learned throughout the book and provides a clear summary of goals of using service oriented architecture.

The reader is expected to have understanding of Java to follow the examples throughout the book. Examples are demonstrated on Windows machines, but could be followed on any other platform as well without having the hassle of setting up a different environment. That is one of the advantages of Service Oriented Architecture with Java, because it basically can be ran everywhere.
When you work your way throughout the book, you will discover different clearly illustrated diagrams and other informational graphics. There are more than enough images to make the image not a boring theory book, as the images often provide a better understanding of different explanations of architecture and setups throughout the book.

The book covers a small setup with Apache Axis 1.3 and mentions to use this opposed to the more recent 2.0 version because more software is being implemented on top of the 1.x series of said web service. However because the reader is starting to learn about SOA, it would have been great to see some of the differences and read why 2.0 hasn’t been adopted much yet. I would have liked to see a bigger comparison between those two versions, but as the authors point out, there is a great community for both versions which provides a lot more background information if you want to look further into the more technical information that isn’t provided in the book yet.
This book is a good way to get your feet wet in using web services to build and architect powerful Java applications for your business. I am no big Java developer yet, and I needed this book to navigate me through the different pieces of software available, it succeeded very well at that point. I was fond of the clear writing style, which has always been the case by books from Packt Publishing. The book also has been written in a logical order, putting case studies at the end of the book so they are better to follow. Most technical books I own are written in a way that allows you to jump from chapter to chapter in an order that you need them, but I found this book to be a solid line of information of which the difficulty grade builds up from beginning to end. As a developer and software architect I am really appreciating how well this book has been written for this audience, it’s almost as if it was written especially for me and the knowledge I had of service oriented architecture before starting with this book.

Getting our definitions right

iTunes LP – Technology to show a digital booklet with dvd-like extra’s combined with a full album bought from the iTunes Music Store.

Album – Tracks you get on the release, outside of the .itlp file. This is just the ‘regular album’.

TuneKit – JavaScript engine powering the visual presentation of the booklet and glue layer for iTunes.

Even more tutorials, background information and stuff the big fruit company doesn’t use yet.

Some points in advance

• Roughly drafted points out nicely the metadata in the index.html showing features used by the Apple TV, but fails to mention the specific apple-tv style declarations found in the css/style.css (@media (-webkit-apple-tv))
• Every LP contains the same codebase for TuneKit, for instance Tyrese Gibson’s Mayhem includes a comic, yet Jay-Z’s Blueprint 3 doesn’t but still contains the classes for the comic content. One could exclude this properly as it’s unused.
• TuneKit is very well written and is very straightforward in its usage. It contains some helpful comments here and there, but lacks real documentation (as it should in a ‘release’).
• Jay Robinson mentions, when talking about DRM, your store account being stored inside the plist. Don’t forget that all purchases from the iTunes store contain the copyright in the metadata tag cprt from your AAC/M4A, and your store account in apID.

Files and folder

• controllers/ – iTunes LP specific controllers, used to manage the songlist/songplayback and all other album specific code
• controllers/data.js – important file used to maintain the ‘datamodel’ from the application
• index.html – main entry file, used to link in all controllers, TuneKit, and css files. Mostly contains a single DIV element to build a container for the application to run in
• <album name>.itlp – 0 bytes, doesn’t do much, probably either a left over or used for a single check for validity
• iTunesArtwork – High resolution jpeg image containing the album cover
• iTunesMetadata.plist – Used to store all information about the buyer and track/album information, home of track/xid mappings
• manifest.xml – unclear what this does, as it doesn’t get referenced inside the application code
• src/ – TuneKit folder, contains all classes relevant to the library
• views/ – All album specific views, clearly seperated from the application logic

Creating your digital enhanced album

The easiest way to get started is by creating a skeleton from a pre existing iTunes LP. You remove all files deemed not needed for your custom implementation. This basically means deleting data folders like audio/, stripping the css to only the first few selectors and removing all controllers and views. You might want to  keep song*.js inside the controller folder. You’ll end up with basically a small folder structure with TuneKit and a single html file and css file. You then start editing the iTunesMetadata.plist and manifest.xml according to your details. Make sure you remove your buyer information, or substitute it with dummy data. From here on its pretty straightforward webdevelopment, you just use TuneKit to manage your views and your controllers and use the provided SonglistController or your own management for playing the iTunes tracks (when the metadata is correct). It might be wise to look into the new features provided by webkit (such as CSS Animations, @font-face font embedding and those other neat tricks found in the current batch of iTunes LP’s).
Debugging can be done in Safari for the most part, unless you access the window.iTunes object, most of its data isn’t available then. Take notice of the fact that there is a build in debug feature, but we haven’t found a way to access that information yet. So document.write is your best friend here probably.

Mapping tunes to the playlist based on analysis of metadata and xml files and some tinkering in the code

TuneKit uses the BookletController, SonglistController and SongPlaybackHelper to manage the songs delivered with the album. These songs are internally referenced with an XID (For example, Jay-Z’s Death Of Autotune is XID: Warner:isrc:USAT20902100). This XID is referenced by controllers/data.js and manifest.xml and leads back to the iTunesMetaData.plist, where it is mapped in the dict.key/xid-asset-mapping dictionary to the cnId found in the metadata of the m4a files delivered in the album. The plId found in all items points directly to the album in your playlist (used by the album feature of iTunes), this plId is the first id referenced in the dict.key/associated-adam-ids. Basically what happens when your viewController.js asks to play a song, is that it calls songplaybackHelper.playSong with the value from data.js. This causes the songlistController to call the TKNavigationController to jump to a song.

When you want to create an iTunes LP for an existing album in the iTunes Store (assuming you bought it there), it should have these id’s in them. However, when you as an independent artist want to enrich your album, you must set these parameters yourself. It’s better to choose a value very low or very high in the same number range, so you don’t conflict with the library from your users. You can edit and see these metadata tags with a small modified version of the great AtomicParsley.

The window.iTunes object

Looks like you can access a whole load of functions using the window.iTunes object. For instance you can play a track using a relative url to the itlp, or play a track by the cnId in your metadata. We haven’t managed to expose all function signatures yet, but with a bit of trial and error you’ll manage to get the results your looking for. For instance you can build up a playlist usin window.iTunes.findTracksByXID(aXID:String), and play them using the play method. This way you do not need to do the full songlist building as seen in the SonglistController and SongplaybackHelper classes but do a simple management yourself. You could also go on and use the window.iTunes.findTracksByTextfields(aObject:Object) to list tracks without the XID metadata tag.

Publishing your digital enhanced album

The album itself can safely be distributed inside a zip file, people on all supported operating systems can extract these. On Mac OS X you get a resulting .itlp file, which launches iTunes when you double click on it. It should register your album immediatly.
On Windows your zip file file extract a folder, this is because Windows doesn’t do Application Bundles. But no worries here, you can just drag the folder onto iTunes and go with the flow.

Conclusion

Apple did a solid job of creating a nice and easy to use platform for digital booklets. We can only hope that Apple opens this format officially for others to implement and grant usage for the TuneKit library to the public. Where do we go on from here ? My ultimate goal is to let independ music artists enrich their album by providing an itlp free of charge with their digital albums. Other huge steps could be an authoring environment for independent artists, so they can drag and drop their assets and tunes, where a dedicated platform takes care of converting the formats and generating the metadata and code for the files. Think of a DIY booklet generator.

Credits

This guide is compiled by information found in the iTunes Music Store delivered iTunes LP files, research and a bunch of help from Daniël. A bit of credit goes to debdrup for being generally awesome and providing feedback.
Needless to say, iTunes, the iTunes Music Store and iTunes LP are trademarks from Apple, Inc.

Originally published: 2009/09/12.

Our current setup:

• Xen based vps
• 256mb ram (dedicated)
• 500gb monthly traffic
• 2 ip addresses
• Linux OS of choice
• unmanaged

Fliehe & Schwab can create a custom offer to match your needs, just contact them through their website. Try asking them for a quote, you won’t be let down.

We have been using this vServer for just over 6 months now, and only had two minor issues. These issues made a small glitch in our uptime, but support always looks into them quickly and thoroughly. Support is often handled by the owners themselves (Marc Fliehe & Manuel Schwab), or otherwise by someone qualified from their support staff. Because I had some troubles getting bandwidth monitoring up and running, I asked the support desk if they had any suggestions for alternative software to the one I was used to. Just as I suspected, I have gotten a very professional and detailed list of applications, linked to some online resources to read on the matter.

In my opinion Fliehe & Schwab are worth a try if you are looking for a virtual private server in Europe, be sure to mention Oceanius when contacting them.
Any questions about performance or other information you seek may be directed at myself or Alex on our irc channel.

When reading the book, my attention was drawn to chapter 10 which focusses on a migration path from Apache HTTPD to Lighttpd. Having ran through this in the past I really wish I had the chapters about virtual hosting with mysql at hand when migrating from Apache. Although I would recommend skipping to chapter 10, if you come from Apache, right after you installed and configured the basic server you should really not miss out on the parts about privacy and user tracking as well as optimizing and securing.

I found the chapters about installing webapplications into Lighttpd not very useful for me, but it contains a lot of configuration examples which you should check out if you want to install WordPress, Trac, AWStats or any of the other mentioned packages. When you look at the last few chapters behind this, you get all information you need to start writing your own Lighttpd modules and integrating Lua for even more extending on your part.

This book seems to contain every interesting part of Lighttpd which is usually scattered around the wiki, forums, blogs. This makes it probably the only manual you will ever need to get started with or getting the most out of your current Lighttpd installation The expertise of the writer comes in handy throughout the whole book and contains very good information in the notes and information blocks found on most pages. It’s not just a manual, it’s your map for navigating around Lighttpd’s world.

Lighttpd – Installing, compiling, configuring, optimizing and securing this lightning-fast web server.
Written by: Andre Bogus
Published by: Packt publishing
Language: English
Book: Paperback of 236 pages
Release date: October 2008
ISBN: 1847192106
ISBN 13: 978-1-847192-10-3

Met de introductie van Mac OS X introduceerde Apple de zogenaamde Quartz technologieën, bestaande uit Quartz 2D en de Quartz Compositor. Deze twee systeemonderdelen zorgen voor de beeldverwerking van Mac OS X, waar Quartz 2D de tekenbibliotheek is voor interface elementen, en Quartz Compositor de laag tussen het systeem en de videokaart representeert. Waarom dit interessant is? Daar kom je pas achter als je Quartz Composer opstart. Quartz Composer is een applicatie waarin je visueel kunt programmeren. Dit wordt een node-gebaseerde applicatie genoemd, je kiest elementen en plaatst die op het projectcanvas. Wanneer je een set elementen hebt, verbindt je de input en output hiervan met elkaar, waardoor je een set beelden op je scherm kunt weergeven.

Quartz Composer kan overweg met verschillende soorten inkomende bronnen, zoals RSS-feeds of bijvoorbeeld een joystick of gamepad. Oorspronkelijk is Quartz Composer als VJ-applicatie ontwikkeld, voordat Apple het overnam, je kan hier bijvoorbeeld sporen van terug vinden in het programma Quartz Composer Visualizer, wat een Quartz Composer-project over een netwerkapparaat of externe monitor kan weergeven.

Als je aan audiosoftware werkt op je Mac, dan is het programma AU Lab eigenlijk onmisbaar. Dit is een programma wat je kunt gebruiken om een net geschreven Audio Unit in te testen. Je hoeft dan niet Logic of Ableton Live op te starten, en te wachten totdat je Audio Unit is ingeladen. Een Audio Unit is een plugin die in meerdere programma’s op Mac OS X te gebruiken is. Door de dichte integratie met Apples Core Audio is het helaas niet mogelijk een Audio Unit uit te wisselen met bijvoorbeeld een Windows of Linux gebruiker. Het programma biedt veel statistieken zoals de vertragingen van audiosignalen, en hoe deze ontstaan als je meerdere Audio Units aan elkaar koppelt. Tevens biedt het programma een uitgebreide mixer, en is in staat multimediabestanden af te spelen. Je komt dus niets te kort vergeleken bij een volwaardige audio gerelateerd programma.

Core Image Fun House is eigenlijk voor afbeeldingen met Quartz Filter, wat AU Lab is voor Audio Units. Het is een programma waarmee je gemakkelijk alle geregistreerde filters kunt testen, om te kijken wat jouw filter doet met een afbeelding of welke filter het meest geschikt is voor een bepaalde toepassing.

Onder UNIX systemen gebruikt men het programma Top om bepaalde statistieken van het systeem te bekijken, zoals processor- en geheugengebruik voor een bepaald proces. Binnen de Developer Tools wordt het programma Big Top meegeleverd, een grafische schil rondom het gereedschap Top. Dit programma is goed te gebruiken als je niet de details van Shark of Instruments nodig hebt, en snel wilt bekijken of de systeembelasting in het gareel blijft. Onder de kleine maar nuttige programma’s vinden we ook Spin Control, speciaal ontwikkeld om te achterhalen waarom je systeem aan het ‘strandballen’ is. Het programma leest uit het systeem welk proces de systeemkernel vertraagt, en houdt hier uitgebreide details voor bij. Hieronder vind je een voorbeeld van het moment waarop Quartz Composer even bleef hangen, je kunt zien dat elke functieaanroep aangeeft waar hij mee bezig is geweest en hoe lang. Je kunt dan beoordelen of dit te lang is.

Als laatste in dit artikel bespreken we Thread Viewer, een programma om te achterhalen wat voor threads een applicatie gebruikt, en met welk doel. Een thread is een opsplitsing van uitvoerbare code, waardoor een programma meerdere bewerkingen parallel aan elkaar kan uitvoeren op de processor. Dit heeft vaak een grote snelheidswinst ten gevolge, maar door de complexiteit maak je vrij snel fouten. Een kleine fout kan je hele applicatie laten vast lopen, daarom is het heel belangrijk om goed te kunnen uitzoeken waar het precies misgaat. Thread Viewer is een kleine parel, en versnelt de nachtelijke uren die menig programmeur kwijt is aan het opsporen van de geslaagde en mislukte acties van zijn threads.

Gezien dit het laatste artikel is in de serie, wil ik jullie vragen of alles duidelijk is en vooral of het nuttig is en je aanspoort je meer te verdiepen in deze set van gereedschappen. Vragen over de inhoud van de artikelen of andere gerelateerde onderwerpen beantwoord ik graag in de reacties op dit artikel.