Here we go. Welcome to this talk. My name, I'm Colin Ferrer. This talk is about building

server applications using Objective-C and GNU 7. Well, the reason I'm giving this talk really is because this is an argument which most people can ignore. Actually, GNU step is usually identified with this GUI development framework, mostly for GUI

applications. But in fact, it's composed of two parts. One is GNU step base, which is a new graphical kind of foundation Objective-C, and the other part is GNU step GUI, which is more of a graphical style. Now, GNU step base is actually the most complete and truly

testy and extensively polished part of GNU step. So it's actually a really cool and finished piece of software you can use. But it's really little known. It's actually little known to the public, in a sense. The company I work for has been running very large-scale applications on this,

like big messaging servers or SMS, we've done videos and stuff. And it really works really well. So I've always wondered why nobody else was doing it. So I give this talk just to give an overview of what you can do on how you can use this stuff. By the way, if you've

been to the talk yesterday, this is kind of an open page for that. Objective-C, which is the language used by GNU step, is the programming language. If you're using GNU step to do server applications, you are going to use Objective-C. There's not much point otherwise. Well, there are some other options which we'll discuss in the end,

but this is your main option. Obviously, Objective-C is a strict superset of C, meaning anything you can do in C also works in Objective-C. You can compile and link Objective-C libraries in your Objective-C program, which means particularly for server stuff. It's

just any C library, you can just link it in and use it. So the main difference between Objective-C and C is that Objective-C adds a number of new features if you want, some

syntax, some constructs that you can use that allow you to define classes, gain objects, instant state, methods, invoke methods, et cetera. And actually, quite a few pretty advanced stuff that sometimes you don't even find in higher level languages like forwarding or categories, et cetera. Why? So why is Objective-C so special? In

fact, why is Objective-C so good for server applications? Because I think it's a perfect match. And the reason is, first of all, it's just C. It's compatible with C libraries. It can be as fast as C if you just use the kind of C subset

of it. So if you're using, writing your server and it does that bit of code that really needs to go really fast, you just write C code. You just use CRAs and iterate and everything. But if you can also use its object-orientated extensions to structure your software like in a very good high-level language

to your nice design patterns, very dynamical. And then the nice thing is you can mix the two things. So once you have a good experience, you can actually kind of change your style and a bit of card work, C-like, a bit of card work's more to it. So really, conversely, a wide range of things and

applications you can do with it. So it's extremely flexible. And actually for server application, it's foundation class library is really powerful. It's really good and it's brilliant. Now, why, I think I already answered

that. Anyway, why would you use Objective-C for server applications? I already said that. It's very fast. You can mix it with C. It's an high-level language which you can use to design your stuff properly. And you've got this powerful foundation library. So let's have a quick

look at the foundation kit which is what this talk is mostly about. First of all, glue step base, which is this thing, actually implements the foundation kit, defined by this API from 1994, which defines a

number of classes for an Objective-C foundation very much like that. We'll go through some of these classes later just to give you a better idea of the capabilities of this library. Obviously, you've got obviously the root Objective-C classes. You've got strings, numbers,

data, arrays, dictionaries. Very interesting for servers. You've got run loops, timers. I'll talk about that later. You can do IO, the notification, a lot of stuff. Yeah. Okay. So this was the open step kind of API. This is how glue step actually does. You can run

your stuff on any operating system, in particular, all the various units, variants, which are probably the most interesting. You need a new Objective-C runtime which is shipped with a free software foundation GCC so you won't really need to do much. And obviously that's a bit loose the base. Okay. So let's have a look.

Just a quick look at what actually you need to build server applications with the new step. First of all, we need GCC. Most Linux distributions, for example, I've got a separate package called GCC, it's got an IP number to C. It just gives you the

Objective-C compiler and Objective-C runtime. You need new step name which is a small make file library. It's the official new step build system. Basically, you write some very small and clean make files and then new step name will take care of all the compiling and linking and porting to other platforms.

And finally, obviously, you need new step base which is this implementation of the kind of foundation framework which provides you with this core Objective-C classes you can use.

A couple of important dependencies that you actually need. You need WebXML which everyone has it. This one is a bit unusual. You need this library called FFI. That's because new step base supports forwarding which means you send

a method to an object and then the object, without even really knowing what the method was called, can forward the method to another object which is very good in certain very advanced design. Anyway, you just download that library, install it and that's it. If you want to use HTTPS in the new step base like you want to be able to connect

to HTTPS servers or actually write an HTTPS server, you probably want to use UTLS or OpenSSL. Obviously, you just install those libraries. Now, I have a quick look and this is just to give you an idea of how easy it is

to install, to do until I just pick up an institution. You just need to do up it again or start a package that will then get all your dependencies and you're ready to go. This is instead if you're installing it manually which, for example, is what my company does. We install our service manually. So, it looks imposing

but actually that's really all you have to do. It's not much. You need to install a couple of so GCC, WebXML, OpenSSL, obviously. You get on that, you just do configure install. At that point, you may, if you do like that, it will be installed

and you use block out. So, obviously, you just need to make sure that the linker will find the libraries editing as you go, that sort of thing. Then you get do step make, you configure make, make install. You get do step base in the same means OpenSSL. So, you need to pass this flag,

enable OpenSSL to configure. And the only really kind of unusual way is you need to source the script. There are ways where you don't need to source that at all. But as a first step, just to make sure it all works, you source the script which will set your path, set your

library path and you don't have to worry about that. Once you're a bit more familiar, you can actually do an FHS style store where your programs end up in USB, your library is in USB and you actually don't need that. OK.

So, let's have a very quick look at how you compile it actually in Objective-C user-based program. This is a example, the same example used yesterday. So, import, this is the main header for the foundation for user-based. So, once you import

this header, you have access to all the user-based functionality. And this is just the tiny nslog actually right to the standard error. So, it's typically you use it in service to log stuff. And that is a static string. The syntax add and then the string is actually static nsstring

which we'll talk about later. This is an example green rate file which compiles that thing. Actually, if you have more files to compile, the main file is exactly the same. You just list them over here on your source code files. Then you type make and it will work. So, the structure

of the green rate file. First, you include this com.make. Then you specify the name of your program which is hello. And the Objective-C files composes the program and here you can just list them all. And then you include this thing, this other make file which builds tools. There are different make file fragments

for different things like libraries, bundles which is like a plug-in that you can build in your program. A tool is basically just a non-graphical Objective-C program. So, for server stuff, if you're doing a server, that is exactly what you should use.

Once you've written this, if you source that script which will actually define this variable, you have all the usual commands. So, you can type make, it will build, you can do make clean, make this clean, you can do make install which will install it. It will give you quite brief output like compiling

file. If you actually want to see the GCC command line, the link, exactly, just add these messages before yes and it will be going to variables mode and prints everything that it's doing. You can also use it for make install for example, if you want to see where

things are going. Actually, it then supports a lot of other stuff like all the stuff you usually expect. But probably, you just need to know that. And when you type make, it will tell you there's a special target you can run to get help and it will be printed in the first one. Okay, at

this stage, I'm just trying to do a quick demo but with the thing that basically just kicked out. Anyway, basically, if you put those two files in there and type make, it will compile them so that it's not conducted and then we'll see.

Okay. Now, if you're actually trying to do this, where do you start? First of all, you need to just know a bit about Objective-C, about this glue step base foundation people are using. This page has got a number of tutorials which I actually wrote myself. And it's a good starting

point like for those make files, for some classes. Use the base as an extensive API reference which I think is pretty complete. Okay, almost complete. And that's kind of the URL. So when you don't know what a method does, what a class

does, which class to use, you can go there and just walk around. You can actually, I didn't list it here, but you can actually also go on the Apple website and look at their foundation kit which has a similar API. So sometimes they give you misleading back. Now, okay, let's have a look at like the basic classes of

glue step base such as strings or arrays or dictionaries, et cetera. It's got quite an interesting design. You would expect you can't do much with those

such basic stuff. Everyone knows that. But actually glue step base, the foundation kit, has some very interesting ideas in the design of these classes, mostly for performance. One thing it does, it uses this cluster design which means, basically,

it's a way of optimizing the classes without kind of changing the API. So when you created any string, which is a string, you don't always get an object of the same class. You get an object of the, it's called a concrete subclass, which actually is optimized for that type of

string. Well, because Objective-C does dynamic dispatch, when you call a method of the object, then depending on the concrete class of the object, a different implementation will be used. That means if you create a Unicode string or if you create a knaske string, you use exactly the same API, you don't need to know which type of

string you have created. But the library actually will know, and when you do things on the string, it will use the optimized implementation for that type of string. That also is done for arrays, for dictionaries in some cases, and you can even implement your own subclasses.

So if you've got a particular type of string of array that you really have your own way to optimize it, you can actually implement the subclass and then pass it around wherever a string is required. You can pass a string of your own class with your own optimized stuff, and it should

work. The other thing is there is a distinction between mutable objects and new mutable ones. So you've got NSString and you've got NSMutableString. That allows you, that allows the classes themselves, like when you put strings into arrays or dictionaries or new things, to

actually optimize quite a lot because it knows that a string, an NSString has never been changed while an NS... Yeah, so I didn't say that. So the difference is a normal string like an NSString is a string you create and you can never change. If you plan on

changing it, you should create an NSMutableString which, and then you can add characters, remove them, etc. So let's very quickly have a look at these base classes. This is, for example, NSString. This example is the thing that also supports static strings like this one.

Again, this is basically allocated by the compiler. Obviously NSString is a string class. It's got full Unicode support. And one thing which is really key for server stuff is this class class implementation is that ASCII string is

still extremely fast, even if there's full Unicode support. So you can, anytime you want, just put the Unicode string in and it will work. But if you put the NSString, it will still be really fast. So unlike Java, for example, where strings are really slow because it's always in kind of Unicode mode.

Depends on implementation. This is a typical array. That's a property list which is a way of describing those collection classes when you serialize or deserialize them. Anyways, just to make sure you understand an array is this thing. While a dictionary is kind of an associative array or hash

statement depending on the terminology you use. So it's more like that one. So you've got keys equal value. Again, you've got it's important to know if you use the API the only thing you really need to know is you've got the array class, sorry, the NSArray classes right over there, which is static stuff. If you want to change them

you have NSMutableArray and prediction is actually the same. Now, I don't have time to go through all of the glue step based classes one by one. I just want to mention a few

ones that may be good to know. So if you go and look at API, you know where to look. One thing you probably want to do if you're writing a server is run loops. Like, your server will start a run loop and wait for sockets to connect in or wait for some time to arrive to do something

or for something to happen. That's a typical thing. So for that you will use an NSRunLoop. You've got a full event-based model. You've got NSPylangle that allows you to do IO which is you're integrating with your run loop. You've got NSTimer. If you want to use threads you've got this class called

NSThread which you can use. For locking you've got NSLock and there's another bunch of them. Another very nice feature of Mr. Bayes is called notifications. It's pretty easy once you get into it and it's really

kind of addictive. It allows you to connect objects in a very flexible way. So you've got this thing called the notification center. That's the class NSNotificationCenter. You can have objects which can observe notifications. So let's place an object and you specify that it's waiting for

the NSFile download completion thing notification. When something else will post that notification your object will be informed that that event has happened. You specify which method you want to be involved when that happens. So you've got a notification center with various

observers that are observing notifications. Then something else will post the notification to the center and all the observers will get informed. That's nice. It's kind of a standard design pattern because it allows you to link basically the observer to the object posting the notification without actually themselves even knowing each other. There's

this notification server in the middle that acts as a flexible. Obviously if you actually want to use it just have a look at the notification center. If you look in the newstep code you will see it's used a lot. And it's a very good idea to use it in your code as well because it's really flexible.

The other thing that newstep.io the newstep in general do a lot is using delegates. Now this is not really implemented in the library in the sense that you don't need the library to provide you the ability to create delegates. But it's something that is almost everywhere in the API. And it's actually

something you want to do in your own APIs as well in your code. A delegate is basically the idea is in object oriented stuff you usually sub-class the class to extend it. The problem is sometimes that's very heavy. You have to create a sub-class it can be quite messy.

Delegates allows you to extend the class without sub-classing. So you've got your you've got your class that does something and then you add set delegate and a method to return the delegate and then whenever you're using an instance of the class you can set a delegate. And then the class

when it's processing at some point you check if there is a delegate and if so we call the method of the delegate to ask for to delegate some of the processing to it. It's very flexible and it's really good. So it's if you actually even if you are not going to do this

it's a really cool thing to have a look and see how it works in the open step API etc. Delegates. That's just like C-sharp delegates right? Function pointers. Sorry. It's similar to C-sharp delegates right? Where they're basically function pointers You know it's totally different. It's totally different. Yeah. You don't have a function pointer but you just like usually you delegate

or not. So it's totally dynamic. Whereas in C-sharp it must be already there. It must be defined. It's not the runtime thing. So a delegate is an object yes of course. So you've got your object then you've got another object. Let's say you've got

an HTML an XML parser and you want to do SACS stuff where when it finds a tag it will actually put a method in your code. So you can have a delegate which is what you're supposed to implement to actually react to events and then in the XML parser you send the delegate to whatever object you want and then when it finds a tag

you will call a method of the delegate which does something and it goes back. And it finds another tag and you call the method. So that's how it works. That's the idea. Okay. I was going to say that actually I mean I think I'm just getting point but I don't know how that's too different from C-sharp but you also do it in runtime. Sure. The only thing similar to that is the name C-sharp

but it's really different things. Don't worry about it. Anyway I want to say it is a standard design pattern. I'm sure you can find it in almost all the other but here it's really used like In Java it's linear. It's linear to linear. Is it? Well actually

it delegates in Java as well. We do it a ton. The difference is that in Objective-C you do not invoke methods directly but there's actually a concept of the selector which we present the message and it's completely decoupled from the lookup process in the class.

So it's a delegate The delegate can be completely dynamic. You don't need to know in advance what methods are implemented in there. For example if you pass an XML you can write a class which has methods like the give or for any tag you could write a method and the

XML parser could dynamically ask whether it's implemented or not. So it's quite common. Now I understand what's going on. It's like Python just has an attribute if you were looking at it. Yes, I'm sure it's funny that you can learn this.

Another thing that monster base provides is something called distributed objects. Again that's basically it's remote method invocation. You have those minutes of implementation of that. This is quite high level and natural and does use again some of these Objective-C

really dynamical stuff. Basically what you do is you've got your process, you've got an object in your process and you can expose it to the network so other processes can call methods of that object. The fact is the way you use the API it looks as if that object in the remote process is actually

in your own process. It's like an object like everything else. It's very very natural to use. It's great if you've got a number of processes that need to talk to each other or separate forces and just sometimes invoke methods of each other etc. Which can be handy when you're building servers etc. Now I don't have enough time to go to that

but I wrote a nice tutorial on this on that web page so you can have a look and just just get an idea. Now I thought I would look at a few of the most useful libraries you can use if you're doing server development with Objective-C. Obviously the first thing is you can use

any C library you want which is a big new thing actually. Unistep does provide a number of server kind of libraries. Most of them are in the deadly module separation. But I go through the most interesting ones

in this talk. Then you've got other parties that provide some very nice Objective-C libraries for example SOPI from the open workflow project which is a full application server we'll briefly mention that later and obviously there are some libraries for Apple that you can reuse

that are written in Objective-C. They've got a very similar API some of them are actually officially ported to Unistep so I don't know if you got some weird format you need to parse you may find something for Apple something for Apple that will just do it. First thing we're going to quickly discuss is just

the database libraries because if you're doing server development chances are you will need to connect to database. The first thing you can do obviously is just use your own fabric C library if you have one or so if you're connecting to Postgres you could just use the Postgres C binds and just use that.

Knusta provides two database libraries which I will discuss in great detail one is called SQL client the other one is called GDL2 finally if you use SOPI for example SOPI has got its own database layer which obviously if you're using SOPI it's definitely the best choice. If not

I'm not so sure you probably just want to use one of those. Let's have a look at these two. First of all SQL client. SQL client is just an SQL layer so it's pretty kind of low level in the sense you write SQL code and you just execute it. As go backend

bundles. A bundle as I was mentioning before is kind of a terminology for a plugin as go plugins for the different databases Postgres these are the ones that are currently provided in the standard distribution as Postgres, MySQL SQL lite and Oracle the focus of this library is

really on high performance and it really does provide cool stuff there. It does connection building obviously. It does all the transaction support. Now and obviously it does query caching so you can do a query and say that you want it to be cached for 10 minutes so if later on your code does the same query

it will just hit the internal cache. The other thing you can do very nicely is batching updates or inserts. If you if you're doing really high performance stuff it becomes it can become important to just batch a number of writes in a single

transaction which is executed faster so this allows you to as your code goes it cannot take statements to be executed to a transaction and when you reach the end you just execute them all and if the transaction fails you will actually if you want just retry all the insert or updates one by one

to make sure that you if one of them is wrong you won't destroy your entire transaction. GDL2 has got a completely different approach it's trying to go for the high level stuff. So this basically provides you an object to relationship mapping framework. It will

automatically convert your database stuff into objects it allows you to it does extensive use of those KVC KVO things which are so cool in Objective-C which allow you to change stuff into other objects to observe them react so and basically

strong MVC pattern very nice stuff has got an SQLite layer at the bottom which again has got different adapters for different databases it's really good for rapid development um so you got this

well I'm going to use classes but in other classes even there's a good program to model your database and then how do they compare? well if you're performance oriented you just want to use SQL client

that makes sense particularly if you basically going to write and tune every single query anyway if you require that level of sophistication in terms of performance obviously you don't want anything to generate queries for you you just want to write your own, tune them one by one and then you should just go with SQL client if you're looking for a

another framework where you can work properly with properly designed stuff etc models, objects, etc you don't want to write SQL GDF queries for you performance is generally good I have to say it's a bit hard to get into because it's modelled

over a world framework from next step called EOF so the people who knew EOF know everything about this the people who have never used it it's usually hard to get into but once you get into it usually people just fall in love with it it's the best thing ever

question how does the majority of GDF 2 compare to the majority of EOF let's say in five or six years ago good question anyone who might have been a star I think

GDF 2 is supposed to be beta I don't know I think there are people using it in kind of real life situation in production but for example I'm not sure if the adapters are fully tested I know the Postgres one works really well I'm not sure about the elements so it may not be as polished as

my question was not so much about the adaptation of the database adaptation but more about the framework itself I used to work with EOF from 2003 so I've looked at it

and that's what it was it was really good and I can imagine that this would be better I guess it has the same I guess it has the same I guess it has the same it has exactly the same

same class names but I can't tell you how mature it is I didn't test it ok that's ok I was just curious I think they are better excuse me

Nicolas is it a requirement of GDL2 that there is a database behind? or is it is GDL2 just a no no no ok sorry

so you've got like Postgres you've got it in your application to access Postgres you use GDL2 so you've got the point is you have a SQL database in the first place and you want to use it but you could but

because I wanted to ask a kind of tricky question you said once you use the GDL2 you never want to use it but what about object oriented databases like Jamstone or I don't have a go yeah what about object oriented

databases like because Nicolas said once you use the GDL2 you never want to use the same thing but if you could just start the transaction transaction and persist your object without doing anything

there could be an object we don't have a object yes it's a problem the problem is that it's just a object relation database you have lots of trouble if you translate to page for example then your object

graph that you want to save to the database is obviously not the same in the context of the object related database actually using GDL2 probably is not using URL you could write an object database pretty easily because the high level stuff which for example binds the user interface to the database

is completely separate from the storage layer so there is something which is called view object store which does all the mapping if you wouldn't want to you could just utilize the object and write them to the disk that would be possible that file or

something else just my question was what if there was no mapping there you don't need to do the mapping using GDL2 it's actually two parts one part is tracking the state of the object which you could use in your object database backend it's some kind of transaction in memory transaction

so it tracks all the changes to the object and when it saves those changes you could either write the object as a serialized form or that's where the mapping kicks in or you can serialize them to a SQL database but that's really independent of the data

those are two different parts there was also one time that file adapter for EOF you could just it's different things you don't need a database as such

another library which is definitely useful is web server library which allows you to basically service this is not really for building web pages

it's more for API transaction APIs where someone is calling your API team do something connect to your database or something it provides a kind of full web server usually use it with a patch in front it's quite handy if you actually need to do that

in case you need to interface with Java stuff there's a GNU step 2 Java interface which allows you to use Objective-C object classes etc from Java which versa Java stuff from Objective-C it's very cool it does work

there's a number of cons though it can be slow so you don't want to overuse it if you have a problem it's hard to debug because of the cross language calls support for cross language sub-classing is actually a bit limited and it's not easy to port to other platforms

one of the last things I wanted to mention was Soapy which is a complete web application server environment it's got an extensive set of frameworks to do a lot of stuff which you usually want to do it's kind of compatible with Apple WebObjects

even if it's got its own Soapy concepts and extensions so it's not perfectly compatible it's kind of clearly divided mostly it's not even trying it's not even trying it does do

it's got a lot of stuff to do XML processing XML RPC etc it does MIME, IMAP, etc it does LDAP as well as on database stuff and it does icon processing if you're interested that's the URL where you will find more information

I forgot to mention who's the web it's a library which is model compatible to Apple WebObjects or next WebObject as it was this time

4.5 I guess and it uses contrast to WebObjects today which is now Java based it's an Objective C and the API is a little bit different the prefixes are

not WO but GSW whatever you can configure that you can configure that I didn't know that it's supposed to be 100% comfortable between WebObjects

and the alternative to ZOP I just looked at the class names and I thought what's that so you don't know what we need anyway, if you lead to WebObjects which is this web development framework by NextStep originally now by Apple ZOP is a very good one

but there's another project which is GoodStep Web which is more compatible less advanced I doubt that, I highly doubt that what do you mean? I think they are stating that they are 100% compatible but I think the core compatibility is much better

ok so we have 400 legacy applications for the ZOP and they work any more questions? thank you very much

if you want more information at the website the mailing list you can ask questions at Google