As said previously, I’ll now focus only on the development of the XEOS Operating System, and related projects.

Enjoy!

It was a tough decision to make, as it implies the discontinuation of all previously published software.
But I really needed to stop focusing on the past, and on software I originally developed years ago.

Simply some fresh air, in order to focus on new/actual stuff and personal projects.

The eosgarden website will stay as-is, but will no longer be updated.
All published software have been discontinued, meaning they won’t be updated anymore.
Commercial software are now completely free to use (a valid serial number is provided on the download page).

That’s the end of a long story, but I have to admit it feels good.
Maintaining all this stuff was just too much, between my work as a development engineer for DigiDNA (an awesome swiss-australian software company), my current and personal code projects, and my private life.

So here we go, ready for a complete new start.
But this time, no more commercial software, and in fact no more end-user software at all.
I’ll just focus on the personal projects I want to develop, like the XEOS Operating System, and related stuff.
A new web home will soon be launched, for all of this stuff, so stay tuned…

And hopefully, I’ll have some more time blogging now… : )

Live diagnostics are now working well.
I modified Codeine’s console area to provide live diagnostics, as well as the output console.
The whole stuff now looks like this:

On the right, you can select the output console, or the code diagnostics (here with a well formed code).

Diagnostics are provided in real-time:

In that example, I didn’t include the necessary C library headers, hence the errors.

Code completion is more complex, but it’s now beginning to work:

Code-completion results still needs to be filtered, and the final output will of course provide useful infos, just as xCode autocompletion.

So stay tuned. I’ll keep posting here updates about Codeine. : )

Codeine is a full-featured code editor, runner and debugger for OS X, supporting C, C++ and Objective-C.
It uses Clang/LLVM as compiler/linker toolchain, as well as for syntax highlighting, live diagnostics and code-completion.

I always dreamed creating such an editor – now it’s finally here and running (well, for most parts).

Development as started 2 months ago, and it’s getting really fast.
I’ve actually no idea when version 1 will be ready, but I’ll keep posting here about the project’s advancement. So stay tuned… : )

For more infos about the project, please visit: www.codeine-app.com

Today, Apple made iOS 6 beta 4 available to registered developers.

From a developer’s perspective, there’s quite a lot of changes.

New APIs, new frameworks, changes in the default UI behavior, better iCloud support (let’s say so), etc. As usual you may say.

It’s not really the same from a user’s perspective, except a few and discreet UI changes and a FaceBook integration (yeah, now my calendar is full of crappy events from «friends»!).

But wait… There’s actually one more thing…

The first iOS 6 beta introduced a brand-new Maps app.

Google’s technology is out. Apple rolled-out its own system (or so), now with 3D support. Neat!

But unfortunately, after a few uses, it turns out this new Maps app is slightly less usable than the previous one, which used Google-Map’s services.

The 3D stuff is nice, indeed, but very limited (for now). And it’s actually not as nice as the new 3D stuff from Google.

So what?

It seems Apple and Google are no-longer friends. Wait, were they once actually?

With iOS 6 beta 4, it’s even worse: Apple removed the default YouTube app.

YouTube is owned by Google, so it’s not really a surprise.

But again, let’s think from a user’s perspective, not from a lawyer’s perspective, as Apple’s engineers and decision makers seems to do now.

Accessing YouTube contents will now require downloading a third-party app, maps and associated services are now less accurate…

What’s next? Maybe we’ll have in a few weeks iOS 6 beta 5, with an Apple made search-engine for Safari and no option to use Google by default…

I really don’t think this is the right way.

Apple’s past shows us that sometimes custom proprietary technologies are not the right way of doing awesome stuff.

Personally, it remembers me stuff like ADC (Apple Display Connector) port. Remember that?

This was actually brilliant.

Back in 2000, introduced with the Power Mac G4 Cube (actually one of my most beloved machine), this was a proprietary modification of the DVI connector, allowing analog and digital display signals, USB and power from the very same cable.

It was just a dream. One cable to rule them all, finally!

I first thought that all displays (even PCs displays) would soon adopt this, as a new standard.

But this was unfortunately proprietary stuff, and the whole stuff ended as a flop.

I’m still crying when I see my 17-Inch CRT Apple Studio Display under my desk, covered with dust.

Recently, Apple rolled-out some amazing new technologies, in partnership with big companies, like Intel.

It seems they have finally learned from all that past.

Now we have for instance Thunderbolt. As it’s also developed by Intel, it guarantees a standard, even in the PC world.

Having such a standard guarantees the technology won’t go away, as the ADC did, and guarantees we’ll have soon tons of compatible hardware from the PC market.

Note I previously said: «It seems they have finally learned from all that past».

With iOS 6, the new Maps app and the removal of YouTube, I’m quite afraid they are beginning to do the same mistake again.

Maybe (and let’s hope so) it’s just me. And I would really enjoy being wrong about all this.

But I can’t stop thinking about it.

We’ll see actually. And of course Apple is now strong enough to do mistakes that would have been hard to recover from a few years ago.

But thinking as lawyers is not thinking different.

So please guys, think about us, poor stupid users, who just don’t care about all your patents…

A few month ago, I decided to update my `FileSystem` iPhone app, available on the AppStore since a few years now.

The purpose of the App was to let you access (read-only) the complete iOS filesystem, displaying every directory, file, file contents, etc.
Just like a Finder on OS X.

When I started iOS development back then, being an experienced Cocoa developer, I suffered from the lack of informations about the filesystem, the organization of files, etc.
Of course, I knew that all apps were sandboxed, but as a developer, I usually like to know how stuff is done on the platform I am developing for.

So the first test app I actually created was this one, as I wanted to see how the iOS system actually looked liked.
It helped me a lot understanding iOS, and the sandboxing system.

As it helped me, I decided then to clean-up the project, provide a better UI, and publish it to the AppStore, as it would maybe help other developers.

Of course, I knew that the app would certainly be rejected, even if it was perfectly clean.
No private API, no hidden feature… Everything was in accordance with the AppStore review guidelines.

I published it, and it was accepted. Hooray!
I even published a small update, to fix a crash on iOS 5 (the app was originally made for iOS 3).

And by the way, the app was available for free.

The app was working nice, I had some good reviews, but unfortunately, it wasn’t an universal app, so it wasn’t available for iPad.
Of course, the iPad did not exist when I developed the app.

So I decided to update it.
In fact, I rewrote it from scratch as an universal app, adding some extra features (like showing the iOS partitions, better and faster previews, open-in features, etc)  and a smoother and cleaner UI.

I was pretty confident, as the app was accepted twice.
Moreover, the update also sticked with the AppStore review guidelines.
No editing, so no security problem for Apple; as an iOS developer, I’m perfectly OK to play the Apple’s rules.

So I uploaded the new version (2.0) on the AppStore.
The review process began. «Waiting for review», then a few weeks later, «In review». Nice.

Then I received a very strange mail from the AppStore review team:

Subject: Your app requires additional review time

Dear Jean-David,

We are currently reviewing an app that you submitted for inclusion on the App Store, and want to let you know that the review process will require additional time. We apologize for the delay and will provide you with an update on the status of your app as soon as possible.

Sincerely,If you have any questions or concerns regarding this notice please contact us at appreview@apple.com .

App Review

Wow… What was this?
I published several iOS app, mainly for clients,  but I never received this kind of mail.
What was happening?

I searched a bit on the internet, and discovered that the Apple App Review Team uses this when they don’t want an app an the AppStore, but have no legal right not to allow it.
Apparently, some developers have such an app in this special «in review» state for more than a year.

Additional review time. When it becomes more than a year, I guess lots of developers will turn to another app…

I decided to wait, to see what could happen.
Two month later, without a single answer or explanation from Apple,  I decided to contact them.

I explained the situation, very politely, asking if I could do something to help the review process, etc.

A few hours later, the app status changed to: «removed from sales», meaning it was not available anymore on the AppStore.
Yep, Apple just killed it.

I then received an email from Apple’s WorldWide Developer Relations’s team:

Hello Jean-David,

My name is XXX and I’m writing on behalf of the App Review Team at Apple.

I would like to talk to you about your app.

At your earliest convenience, can you please reply to this message and provide a phone number where you can be reached between 6:00 pm and 9:00 pm (your local time)? Additionally, if you can be reached after 9 pm your time, please let me know.

Once I receive your phone number, I will contact you at my next available opportunity.

Thank you and Best Regards,

Mmmmm… It just looked bad.
Anyway, I had this phone call.

The person at Apple told me my app was removed from sales, as it was accessing files from the system, and as it should only access files from it’s own sandbox.
I then tried to explain the purpose of the app, insisting on the fact that no editing was allowed.

The person then explained me that, at Apple, some «business models» are not wanted.
Ok… So it’s like: we don’t like your app, but we can’t reject it officially, so we are going to kill it, and ask you not to submit it anymore.

Neat…

So here I am. It’s not really a problem, as the app was free, and as I never tried to build something on it.
But I just feel bad about Apple policy.

So the app is no more available from the AppStore, and will never be.

What’s the result of all this, now?

Well, the project is freely available on GitHub, published under an OpenSource license.
I’ll also publish the app for free on Cydia as soon as possible, for jailbroken iOS devices.

Nice  Apple… You just dislike OpenSource (most of the times), and fight against JailBreak…
Maybe you should do something so developers don’t feel forced to break your rules.

Ok, maybe I’m a bit sarcastic. It’s just a little iPhone app, for other iOS geeks…

But think a minute. Today’s date is May 27, 2012.
On June 1, 2012, all applications on the Mac AppStore are supposed to be sandboxed. You see now?

Lots of fun ahead for Mac developers.

I always loved Apple, and of course I still do.
But times are definitively changing.

Years ago, maybe some don’t remembers or weren’t even born, developers helped Apple not to die.
Now it just seems Apple wants to help developers quitting Mac development.

When coding a Mac OS X (or iOS) application, you are usually going to use Objective-C as main language.
It’s not mandatory, as you can use the old Carbon API, or stuff like QT (C++), but it will usually be easier, at least for all the UI related stuff.

Mixing C with Objective-C is not a problem, as Objective-C is a strict superset of C.
Whether you have pure C code, or if you are linking with a C library, there’s no issue.

Mixing C or Objective-C with C++ is not as easy.
Although C++ was originally based on the C language, it’s not strictly a superset, so trying to use C++ code from C or Objective-C may not be always easy.

Of course, with Objective-C, you have the possibility to use Objective-C++ (.mm files).
This way, you can use all the C++ features within Objective-C code.

But sometimes, this is not wanted. Moreover, it’s of course impossible with pure C.

Before going on, let’s take a little example in pure C.
We are going to code a typical «hello world» application.

For this, we decide to have a file for our program’s main function, and another file for utility functions.

Let’s start by the utility functions file.
First of all, we need to create a header file, named «lib.h»:

We declare here the prototype of a function named «say_hello».
We are now going to provide an implementation, in a new file named «lib.c»:

Nothing special here.
Now let’s create our program’s main function, in a file named «main.c»:

Here, we just use our «say_hello» function, before exiting the program.

Let’s take a look at the compilation.
We are going to generate an object file (.o) for each C file, and then link them together.

Let’s start with «lib.c»:

From the «lib.c» source file, we generate an object file (machine code) named «lib.o».
We can use the «nm» command to list the symbols available in that object file:

It will output:

We can see here our «say_hello» function.
As you can see, it has a leading underscore. This is totally normal.

Now let’s create an object file from «main.c»:

Now, we have two distinct object files.
In order to create an executable, we need to link them. This can be done with:

This will create an executable named «test», which will just print «hello, world» when run.

Piece of cake.
But now imagine we want to use C++ for the library part, and C for the other parts.

First of all, we are going to rename «lib.c» to «lib.cpp».
The «lib.h» header doesn’t need to be changed.

We are also going to replace the implementation of the «say_hello» function, so it uses «IOStream» instead of «printf()».
Our «lib.cpp» file will now look like that:

No problem here, just a standard C++ hello world.
Let’s recompile everything (note that we are now going to use g++ instead of gcc for the C++ file):

No problem here. Let’s link the two files in order to create an executable, as previously:

Unfortunately, you’ll have linker errors here, such as:

Ok, obviously we are not linked with the C++ standard library.
This is because we used gcc to create our final executable.

So let’s use g++ for the final stage.
Note that we will still use gcc for the «main.c» file, as it’s still pure C code.
No need for a C++ compiler here:

We still got a linker error:

Here, we can see we are effectively linked with the C++ standard library, as the errors for the «std::» members, like «std::cout» are gone.

But it seems that the C++ version of our «say_hello» function is not found.
Let’s take a look at the «lib.o» file, to find out what’s wrong.
We are going to use the «nm» command again, to list the symbols available in that file:

The result is:

There’s no symbol for our «say_hello» function.
Instead, we have:

What’s this «_Z9» prefix?
Ever heard of «name mangling»?

First of all, remember that C++ has built-in support for function overloading.
It means that the following example is perfectly valid:

Here, we’ve got three functions named «foo».
In C or Objective-C, this is not possible, as a symbol can only be defined once.

In C++, this is called «function overloading». A function (or method) can have multiple implementations, as long as there is a difference in the return type and/or the arguments.

The compiler will then generate three different functions, and automatically choose which one to use when you issue a call, depending on the return type and the argument types.

In order to do this, as the compiler will create different functions, it will have to use different symbol names.
That’s why C++ functions (or methods) have a modified symbol name, in the resulting object code.

So how can we deal with this, from our «main.c» file?
With Objective-C++, it would have worked, of course. But not with pure C, or pure Objective-C.

Fortunately, there is a way to tell the C++ compiler to comply with C-like declarations, so it won’t use its calling conventions (with mangled names) when producing object code.

This way, our C++ function will be callable from pure-C (even if it’s implementation uses C++ features).

In order to do this, we just need to change the «lib.h» header file:

When the C++ compiler is used, the «__cplusplus» macro is defined.
Now, in such a case, our function’s prototype will be wrapped with:

This will tell the C++ compiler that we intend to use everything inside the braces from C code, meaning it will generate symbol names according to C.

So let’s recompile our «lib.cpp» file into object code:

Now, if we run «nm», we can see:

Hurray! The symbol name for our «say_hello» function is now «_say_hello» as with pure C.
It means we are now able to link our object files, in order to produce the executable:

No error here. Our executable was successfully produced, and is working fine!

Of course, when using «extern “C” {}», you can no more use C++ stuff like function’s overloading, or namespaces (and of course classes).
But this way, when providing functions implemented in C++, you can make them available to C code, and so to Objective-C as well.

Basically, all warning flags are activated. I had to look at the Clang source code to find all of them.

I also created a header file which automatically sets those flags, when compiling source code.
This way, whether you use an IDE or command-line to compile your code, you won’t need anymore to set those flags, as long as you include the header.
It’s available here on GitHub. Enjoy!

Warning flags list:

• -Wabi
• -Waddress-of-temporary
• -Waddress
• -Waggregate-return
• -Wall
• -Wambiguous-member-template
• -Warc-abi
• -Warc-non-pod-memaccess
• -Warc-retain-cycles
• -Warc-unsafe-retained-assign
• -Warc
• -Watomic-properties
• -Wattributes
• -Wavailability
• -Wbad-function-cast
• -Wbind-to-temporary-copy
• -Wbitwise-op-parentheses
• -Wbool-conversions
• -Wbuiltin-macro-redefined
• -Wc++-compat
• -Wc++0x-compat
• -Wc++0x-extensions
• -Wcast-align
• -Wcast-qual
• -Wchar-align
• -Wchar-subscripts
• -Wcomment
• -Wcomments
• -Wconditional-uninitialized
• -Wconversion
• -Wctor-dtor-privacy
• -Wcustom-atomic-properties
• -Wdeclaration-after-statement
• -Wdefault-arg-special-member
• -Wdelegating-ctor-cycles
• -Wdelete-non-virtual-dtor
• -Wdeprecated-declarations
• -Wdeprecated-implementations
• -Wdeprecated-writable-strings
• -Wdeprecated
• -Wdisabled-optimization
• -Wdiscard-qual
• -Wdiv-by-zero
• -Wduplicate-method-arg
• -Weffc++
• -Wempty-body
• -Wendif-labels
• -Wexit-time-destructors
• -Wextra-tokens
• -Wextra
• -Wformat-extra-args
• -Wformat-nonliteral
• -Wformat-zero-length
• -Wformat
• -Wformat=2
• -Wfour-char-constants
• -Wglobal-constructors
• -Wgnu-designator
• -Wgnu
• -Wheader-hygiene
• -Widiomatic-parentheses
• -Wignored-qualifiers
• -Wimplicit-atomic-properties
• -Wimplicit-function-declaration
• -Wimplicit-int
• -Wimplicit
• -Wimport
• -Wincompatible-pointer-types
• -Winit-self
• -Winitializer-overrides
• -Winline
• -Wint-to-pointer-cast
• -Winvalid-offsetof
• -Winvalid-pch
• -Wlarge-by-value-copy
• -Wliteral-range
• -Wlocal-type-template-args
• -Wlogical-op-parentheses
• -Wlong-long
• -Wmain
• -Wmicrosoft
• -Wmismatched-tags
• -Wmissing-braces
• -Wmissing-declarations
• -Wmissing-field-initializers
• -Wmissing-format-attribute
• -Wmissing-include-dirs
• -Wmissing-noreturn
• -Wmost
• -Wmultichar
• -Wnested-externs
• -Wnewline-eof
• -Wnon-gcc
• -Wnon-virtual-dtor
• -Wnonfragile-abi2
• -Wnonnull
• -Wnonportable-cfstrings
• -Wnull-dereference
• -Wobjc-nonunified-exceptions
• -Wold-style-cast
• -Wold-style-definition
• -Wout-of-line-declaration
• -Woverflow
• -Woverlength-strings
• -Woverloaded-virtual
• -Wpacked
• -Wpadded
• -Wparentheses
• -Wpointer-arith
• -Wpointer-to-int-cast
• -Wprotocol
• -Wreadonly-setter-attrs
• -Wredundant-decls
• -Wreorder
• -Wreturn-type
• -Wself-assign
• -Wsemicolon-before-method-body
• -Wsequence-point
• -Wshadow
• -Wshorten-64-to-32
• -Wsign-compare
• -Wsign-promo
• -Wsizeof-array-argument
• -Wstack-protector
• -Wstrict-aliasing
• -Wstrict-overflow
• -Wstrict-prototypes
• -Wstrict-selector-match
• -Wsuper-class-method-mismatch
• -Wswitch-default
• -Wswitch-enum
• -Wswitch
• -Wsynth
• -Wtautological-compare
• -Wtrigraphs
• -Wtype-limits
• -Wundeclared-selector
• -Wuninitialized
• -Wunknown-pragmas
• -Wunnamed-type-template-args
• -Wunneeded-internal-declaration
• -Wunneeded-member-function
• -Wunused-argument
• -Wunused-exception-parameter
• -Wunused-function
• -Wunused-label
• -Wunused-member-function
• -Wunused-parameter
• -Wunused-value
• -Wunused-variable
• -Wunused
• -Wused-but-marked-unused
• -Wvariadic-macros
• -Wvector-conversions
• -Wvla
• -Wvolatile-register-var
• -Wwrite-strings

Root directories for websites can now be chosen individually, making it easier to organize your files on your hard disk.

The update is available free of charge from the integrated updater.
A full installer is also available to download.

Version 1.3.0 also includes a 14 days trial period.
So just give it a try, I’m sure you won’t regret it! Enjoy!

The first one, named «AutoPurge» is a UI agent, placed in the menu bar, that automatically frees unused memory based on a specific user-defined time interval.
It’s useful for Macs with low memory capabilities, or for users that use a lot of huge programs, like VMWare, Adobe Creative Suite, Xcode, etc.

Mac OS X doesn’t always reclaim the used memory immediately, when a program exits. So if you use a lot of software, your Mac may become slow, as the system will then have to use the hard disk as memory, when all the physical RAM is used.

AutoPurge helps the system to recover the unused memory, making it available again to applications.

AutoPurge is available for $0.99, from the Mac AppStore:
http://itunes.apple.com/us/app/autopurge/id480739949?mt=12

The second one, called «SOStatus», provides you with real-time informations from your StackOverflow account, from the menu bar.

It’s available for $0.99 too, from the Mac AppStore:
http://itunes.apple.com/us/app/sostatus/id490656622?mt=12

It’s a GUI front-end for the UNIX manual pages.
It automatically searches your computer for all available manuals, and displays them in a nice way, ordered by sections.

The following features are available:

• Live search for specific manual pages
• Search and highlight in manual contents
• Printing support
• Filtering by sections

You may purchase it from the Mac AppStore, for $1.99.

This release fixes an annoying bug, introduced since Mac OS X 10.7.2.
The virtual hosts were not accessible anymore from a web browser.

It also adds support for PHP 5.4.0 (release candidate). Now, four version of PHP are available.

Next releases will include custom locations for virtual hosts, as well as a 14 days trial.

This is a Mac OS X Lion only update. Users still on Mac OS X 10.6.x will have to stick with version 1.1.
Sorry guys, but it’s time to move on.

As I’m compiling the bundled software (Apache, PHP, MySQL, etc.) on Lion, some of them may not be compatible with older Mac OS releases.
So I decided not to support Snow Leopard anymore, to concentrate on the actual OS version.

I’d also like to speak about the virtual hosts bug, on Mac OS X Lion.

Previous versions of WebStart used the OpenDirectory database in order to manage hosts, instead of using the /etc/hosts file.
This is a much cleaner solution, as it uses a real database, with an official API, instead of parsing and modifying a system configuration file.

Unfortunately, since Mac OS X 10.7.2, there is a kind of bug in OpenDirectory.
The DNS resolver, apparently for performance reasons, no longer asks the OpenDirectory database for hosts.

I tried to find a workaround, with guys from Apple, but no luck.
Apple recognizes that it’s a bug in the DNS resolver, but won’t fix it.
Here’s an answer from Apple about this:

I can replicate the problem as you described it. I spent a bunch of time investigating it yesterday.
At this point I’m somewhat confused. I spent a bunch of time yesterday working my way through the OD daemon’s code to try and figure out what’s going on. However, I think I might get a result more quickly by asking the experts, so I’ve sent a request to the OD daemon engineer to see if he has any insight into this problem. Please stand by.

And finally:

After talking this over with OD engineering, I have an answer for you, but probably not the one you were hoping for: this is a known issue that’s unlikely to be fixed in the near future. The change was made as part of the effort to push all DNS resolution down into the mDNSResponder daemon. Doing this has a number of advantages (there’s now just one resolver, which allows for coherent caching and so on), but it prevents the OD daemon from providing host information (because the OD daemon exists ‘above’ the mDNSResponder daemon, and you can’t call ‘up’ in the stack with causing other problems, typically deadlocks).

So version 1.2.0 of WebStart uses the /etc/hosts file, as there is no other solution for this.

It may be also useful to add another number, called the «build» version, identifying more precisely the software’s version.
Such a number is often represented in a hexadecimal.

You may have for instance: 1.7.5 (12B43)

The build number is especially useful when dealing with betas, where to software’s version number doesn’t change.

If you use a revision control system, such as Subversion (SVN) or GIT, you want to bind the build number to the revision number.

So here’s a quick tutorial for the Xcode users, using Subversion.
We are going to automatically update an entry of the «Info.plist» file, with the SVN revision number.

In your application’s «Info.plist» file, add an entry called «BuildNumber», and define it as a number.

Then, on your target’s build phases, add a new «Run Script» phase, and place the following content:

That’s all. Simply replace the “MyApp/Info.plist” string with the actual path of your «Info.plist» file.

Each time you build your application, the script will update the entry in the «Info.plist» file with the latest revision number from your SVN repository.

To access the build number in Objective-C, you can use:

You can the build a full version string using:

I’m just tired of questions about this on StackOverflow.

Objective-C programmers usually don’t think about C code while coding. I personally think this is a big mistake (it can sometimes apply to C++ programmers too).

Objective-C is just a layer over C. So in order to be a good Objective-C programmer, you HAVE to know at least a few things about the C language.

I don’t know why C has such a bad reputation for Objective-C coders, especially on iOS. And it’s very surprising to see the lack of knowledge of some Objective-C developers.

So once and for all:

If you want to code in Objective-C, learn at least the following C topics:

• Language keywords and their meanings
• Pointers and pointer arithmetic
• C standard library

Those are the (very) basics.

Objective-C is a very nice object-oriented language, with amazing runtime capabilities. That’s true.
But it doesn’t mean you can bypass completely the C language.
A lot of time, you’ll save a lot of processor time and memory, just by knowing a few things about the C language, rather than relying on the apparent simplicity of the Objective-C language.

But that’s a different story. Now back on our keywords…

const

First of all, the ‘const’ keyword.

Ok, it means ‘constant’… So:

declares a constant integer variable. It means it’s value can’t be modified. It’s value is initially assigned to 42.
If you try to change its value later, the compiler will issue a warning, or an error, depending on your compiler settings.
So the following statement is invalid:

That’s pretty easy to understand.
The problem comes with pointers.

Let’s take a look at the following code:

It declares a ‘char’ pointer. Ok… But then what about this:

or

Now read carefully.
The first one declares a constant pointer to a char.

It means the the characters of the string can be modified, but not the pointer value.
So the variable ‘str’ cannot be assigned to another pointer.

For instance, this is invalid:

as your a modifying the pointer value (not the string value).

This is valid:

The ‘str’ variable will then contain ‘hello, world’. Remember: the pointer can’t be modified, the value that is pointed can be.

It’s the exact opposite with the following notation:

Here, you can assign the pointer to another variable, but you can’t change the value.

The ‘const’ keyword is contextual, in a way, when using pointers. It can apply to the pointer itself, or to the value pointed.

So, in order to resume:

A modifiable pointer to a constant integer.

A constant pointer to an modifiable integer.

A constant pointer to a constant integer.

static

The static keyword can have two meanings.

First of all, it can be declared inside a function.
Let's take a look at this example:

The output will be:

Because a simple local variable, as in the 'foo' function, only exists when the function is called. It's destroyed (to be simple) when the function exits.

So for the 'foo' function, the variable is created each time the function is called, with a value of '0'. The value is printed, then incremented.
The function then exit, and the variable is destroyed.

But in the 'bar' function, the variable is declared as static. It means the value will persist across function calls.
It's initialized the first time the function is called, but only at that time. Once it has been initialized, it just exist, so its value will be taken for the next function calls.

Now the 'static' keyword as a completely different meaning when used in a variable declared outside of a function (in the global scope).

It means that the variable will be «file scoped». In other words, the variable, which is global, will be accessible only from the scope of the file which declared it. It won't be accessible from other files.

It's just a way to create global private variable.

For instance, imagine a file called 'foo.c':

From a 'bar.c' file, you'll be able to access the 'x' symbol, if both files are linked together. But you won't be able to access the 'y' symbol, as it's decaled as 'static'.
It means that the symbol for the 'y' variable won't be exported by the linker, when the symbol for the 'x' variable will be.

In other words, you'll be able to access the 'y' global variable only from function declared in the 'foo.c' file. The 'x' variable will be also accessible from other files.

Of course, the 'static' keyword can be combined with const.
For instance:

A constant pointer to a constant integer, that will be accessible only from the file which declared it.

Here’s the current product line:

• DiskAid
  DiskAid is a tool for PC and Mac which enables the use of iPhone, iPad or iPod Touch as an external mass storage device. DiskAid gives access to the device’s file system, transfers text messages (SMS) to computer, allows to copy, edit or rename files and folders on the iPhone, iPad or iPod Touch directly from the desktop. Using a USB connection, it is the safest and most reliable way to access device’s files and folders. Used with FileApp or FileApp Pro transfered files and documents can easily being accessed on the device.
• FileApp / FileAppPro
  FileApp is a file manager and reader for your iPhone, iPad and iPod TouchEasily copy files on your device for a quick look on the road. Powerful and yet still very user friendly, FileApp will let you find the document you’re looking for within seconds.Copying files over to your iPhone or iPod Touch takes place wirelessly (by FTP) or via USB (cable) using DiskAid or iTunes File Sharing.If you are looking for power features such as copy, move, create and rename folders, create folders and text files, multi-selection of items to email or ZIP, make sure you try FileApp Pro ! FileApp Pro is FileApp on steroids, while preserving all the simplicity of FileApp, don’t miss it!
• TuneAid
  TuneAid is an iPod content recovery tool. It will let you import your iPod’s library back into a Folder or iTunes with no effort. Hard Drive crash? Stolen computer? Corrupted system? No problem, TuneAid will salvage your Music!Apple’s iTunes lets you transfer your music to iPhone, iPod or iPad. But this sync function only works one way: from computer to device.TuneAid lets you transfer your music to computer, and in doing so also directly copy to iTunes all your library : ratings, playlists and more, whether its a Windows PC or a Mac!
• PicsAid
  Have you ever noticed that pictures that have been synced into an iPod, an iPhone or an iPad cannot be accessed nor copied back to a computer?Apple’s iTunes lets you copy to iPod, iPhone or iPad your favorite pictures through syncronised albums. But this sync feature only works one way: from computer to device, and it does not allow to copy photos back, nor sharing them anyhow!Your photos remain stuck in the device’s proprietary database ( ithmb ).So how to transfer photos back to your computer ?PicsAid will allow retrieval of all the pictures that were synced with iTunes. In the event of a computer crash or simply in order to freely share pictures, PicsAid will allow to copy all synced albums to any computer you like, allowing sharing and recovery of those precious captures!

Linda Null, Julia Lobur

Thoroughly Revised And Updated, The Essentials Of Computer Organization And Architecture, Second Edition Is A Comprehensive Resource That Addresses All Of The Necessary Organization And Architecture Topics Yet Is Concise Enough To Move Through In A Single Semester. The Text Covers Such Topics As Digital Logic, Data Representation, Machine-Level Language, General Organization, Assembly Language Programming, CPU Organization, Memory Organization, And Input/Output Devices, As Well As A New Chapter On Embedded Systems. Correlated To The ACM-IEEE Computing Curricula Guidelines, The Essentials Of Computer Organization And Architecture Is The Forefront Text For Your Computer Organization And Architecture Course.

Code: The Hidden Language of Computer Hardware and Software

Charles Petzold

Charles Petzold’s latest book, Code: The Hidden Language of Computer Hardware and Software, crosses over into general-interest nonfiction from his usual programming genre. It’s a carefully written, carefully researched gem that will appeal to anyone who wants to understand computer technology at its essence. Readers learn about number systems (decimal, octal, binary, and all that) through Petzold’s patient (and frequently entertaining) prose and then discover the logical systems that are used to process them. There’s loads of historical information too. From Louis Braille’s development of his eponymous raised-dot code to Intel Corporation’s release of its early microprocessors, Petzold presents stories of people trying to communicate with (and by means of) mechanical and electrical devices.

The iPhone Developer’s Cookbook: Building Applications with the iPhone 3.0 SDK (2nd Edition)

Erica Sadun

Want to get started building applications for Apple’s iPhone and iPod touch? Already building iPhone applications and want to get better at it? This is the only book that brings together all the expert guidance–and the code–you’ll need!

Completely revised and expanded to cover the iPhone 3.0 SDK, The iPhone Developer’s Cookbook is the essential resource for developers building apps for the iPhone and iPod touch. Taking you further than before, this new edition starts out with an introduction to Objective-C 2.0 for developers who might be new to the platform. You’ll learn about Xcode and Interface Builder and learn how to set up and configure your iPhone Developer account

Cocoa Design Patterns

Erik M. Buck, Donald A. Yacktman

Mac and iPhone developers are often overwhelmed by the breadth and sophistication of the Cocoa frameworks. Although Cocoa is indeed huge, once you understand the object-oriented patterns it uses, you’ll find it remarkably elegant, consistent, and simple.

Cocoa Design Patterns begins with the mother of all patterns: the Model-View-Controller (MVC) pattern, which is central to all Mac and iPhone development. Encouraged, and in some cases enforced by Apple’s tools, it’s important to have a firm grasp of MVC right from the start.

Cocoa Programming for Mac OS X (3rd Edition)

Aaron Hillegass

There’s a reason that a large slice of the open-source movement has defected from running Linux on its laptops to running Mac OS X. The reason is the Unix core that underlies Mac OS X, and the development tools that run on that core. Cocoa makes it easy to create very slick Mac OS X interfaces for software (as well as to create applications in a hurry), and this new edition of Cocoa Programming for Mac OS X does an excellent job of teaching its readers how to put a Cocoa face on top of code (Objective-C code almost exclusively). If you know something about C and/or C++ programming and want to apply your skills to the Mac, this is precisely the book you want.

Effective C++: 55 Specific Ways to Improve Your Programs and Designs (3rd Edition)

Scott Meyers

This exceptionally useful text offers Scott Myers’s expertise in C++ class design and programming tips. The second edition incorporates recent advances to C++ included in the ISO standard, including namespaces and built-in template classes, and is required reading for any working C++ developer.
The book opens with some hints for porting code from C to C++ and then moves on to the proper use of the new and delete operators in C++ for more robust memory management. The text then proceeds to class design, including the proper use of constructors, destructors, and overloaded operator functions for assignment within classes. (These guidelines ensure that you will create custom C++ classes that are fully functional data types, which can be copied and assigned just like built-in C++ classes.)

The Art of Assembly Language

Randall Hyde

Assembly is a low-level programming language that’s one step above a computer’s native machine language. Although assembly language is commonly used for writing device drivers, emulators, and video games, many programmers find its somewhat unfriendly syntax intimidating to learn and use.

Since 1996, Randall Hyde’s The Art of Assembly Language has provided a comprehensive, plain-English, and patient introduction to assembly for non-assembly programmers. Hyde’s primary teaching tool, High Level Assembler (or HLA), incorporates many of the features found in high-level languages (like C, C++, and Java) to help you quickly grasp basic assembly concepts. HLA lets you write true low-level code while enjoying the benefits of high-level language programming.

Advanced Compiler Design & Implementation

Steven S. Muchnick

This comprehensive, up-to-date work covers advanced issues in the design and implementation of compilers for modern processors, written for professionals and graduate students.

A Retargetable C Compiler: Design and Implementation

David R. Hanson, Christopher W. Fraser

Designed as a self-study guide, the book describes the real-world tradeoffs encountered in building a production-quality, platform-retargetable compiler. The authors examine the implementation of lcc, a production-quality, research-oriented retargetable compiler, designed at AT&T Bell Laboratories for the ANSI C programming language. The authors’ innovative approach-a “literate program” that intermingles the text with the source code-uses a line-by-line explanation of the code to demonstrate how lcc is built.

From a GDB session, type:

The first line will tell GCC to output the assembly code. The second one will create a breakpoint on the main function. You can of course choose another symbol for the breakpoint.

Once done, you can run your program:

In our example, to code will stop at the main function, showing the assembly code:

You can then step to each assembly instruction with the «si» command.

On Mac OS X or Unix-like system, I can use the backtrace() function, from execinfo.h to retrieve a function call stack, when necessary.

This way, when a fault occurs, the debugger can show you where the fault occurred.

As XSFoundation is a portable library, I had to do the same thing on Windows.
I first try using the StackWalk64 function, with no luck.

At last, I found a solution using the CaptureBackTrace function, from the MS API.

The output will be the following:

Here’s the actual code to achieve this:

I’m currently coding eosgarden’s next big thing. A project called XSFoundation.
It consist of a portable C library. By portable, I mean it can run on POSIX compliant systems, such as Mac OS X, Linux, Unix, as well as Windows.

A few time ago, I started an insane project: coding an operating system.
The base for this OS, named XEOS (x86 Experimental Operating System) is now working, and it’s even published on GitHub.

The main boot parts are coded in Assembly, and the 32bits kernel is coded in C. It also include a (not yet complete) C89 library.

I also decided to code another library for this OS, the XEOS library, to simplify C programming for XEOS software.
I ended up with the XSFoundation project. It will be integrated in XEOS once the C library will be complete.

For now, it’s a standalone project, and I decided to make it portable on every OS.

XSFoundation is a C library providing object-oriented-like coding in C, reference counting memory management, multi-threading, base objects like array, dictionaries, sets, strings, numbers, URLs, timers, etc.
The design inspiration comes from Apple’s Core Foundation.

Today, I achieved the final portability steps for Windows, which were multi-threading capabilities.
Now you can have exactly the same code, compiling on Window, Mac or Linux!

I’m now going to code the socket part, so the library will have network capabilities.

The project is also available on GitHub, and is distributed under the terms of the BOOST license:

https://github.com/macmade/XSFoundation/wiki

Feel free to fork me on GitHub, and enjoy!

The OpenCV port for iOS is available on GitHub, as well as the example app.

Enjoy!

I must say I still prefer SVN over GIT, as a version control system. That said, that’s maybe because I got a strong experience with SVN, and not with GIT.

For now, the cool thing about GIT is the local commits. You don’t need an internet connection to commit your files.
For the other features, we’ll see later.

I took the decision to migrate to GIT mainly because of the social part of GitHub.
With a GoogleCode project, you got no visibility. But with GitHub, that’s very different.

People can see what you’re working on, fork your projects, participate easily, etc…
That’s why I’m now going to create GIT projects instead of SVN, even if I’m not as experienced with GIT as I am with SVN.

So just take a look at my GitHub page, if you’re interested: https://github.com/macmade

It’s not a great deal, since there are __x86_64__ and __i386__ macros, but in case you need such an app, it’s available on GitHub, released under the Boost license.
Feel free to use it:

https://github.com/macmade/CPU-64Bits-Check

I also made the icon myself, which is available in 2000px. Also feel free to use it without copyright limitations if you need it!
Enjoy!

I plan to integrate support for the DynDNS service. That’s a feature of MAMP pro, and I was asked for such a feature.
It will be for version 1.1, free upgrade for those with a 1.0 license code.

Next steps will be support for the Trac SCM. I plan to add a GUI over the Trac installation script, so you’ll be able to create Trac projects directly from WebStart.

Mac OS X support a lot of different processor architectures.
From PPC to Intel, including ARM (for iOS), all of these with 32 or 64 bits instruction sets.

When compiling a C file with GCC under Mac OS X, only the current CPU architecture will be compiled by default.

For instance:
gcc -Wall -o test test.c

Will produce an executable supporting only one architecture (similar to the host machine).

The executable format is called «Mach-O», and is specific to OS X.

The Mach-O format supports more than one architecture.
It means you can have a single binary file, which contain code that will run on different CPU architectures.

Apple introduced that format with Mac OS X, while preparing the transition from the PowerPC architecture to Intel.
The same thing was done for the M68K to PPC transition.
But it’s also used to run binaries with 32 or 64 bits instruction sets.

To see what kind of architecture an executable file supports, your can use the «lipo» command.
For instance, on my computer (Intel x86_64):
lipo -info /bin/bash

will return:
Architectures in the fat file: /bin/bash are: x86_64 i386

Meaning the executable can be run on Intel 64bits or 32bits processors.

In order to compile an executable for a specific processor architecture, you can pass the -arch option to GCC.
For instance, to compile a FAT binary, that will run on 64 and 64 bits intel processors:
gcc -Wall -arch x86_64 -arch i386 -o test test.c

Remembers me the good old time of Mac OS 8.5, on my iMac G3!
Enjoy…

When you passed just too many days and nights coding, you’ll certainly think about selling your software.
The question is how?

Selling a software implies creating a web-shop, with credit-card support, having a good serial number system, and maybe an online activation system.

Not easy… When you’re software is ready, you usually don’t want to spend more time for those tasks…

I personally use the «eSellerate» system: http://www.esellerate.net/

They just manage everything. Serial numbers, online activation, custom web-shops, in-app purchase, physical CD delivery, etc…

They provide a very well documented SDK (static library), that you can embed into your software.
No more hassle. It just works…

So if you need to sell software, and don’t want to spend time on other things than developing, just take a look.

Server Stats

Web Server

Address Book

Alerts

Groups

Hardware

iCal

Mail

PodCast

Profiles

Sharing

Time Machine

Users

VPN

Wiki

]]> http://www.noxeos.com/2011/02/24/mac-os-lion-server-side/feed/ 0 http://www.noxeos.com/2011/02/24/mac-os-lion-screens/ http://www.noxeos.com/2011/02/24/mac-os-lion-screens/#comments Thu, 24 Feb 2011 16:30:19 +0000 Jean-David Gadina http://www.noxeos.com/?p=191

Finder – All My Files

Finder -Applications

Finder -AirDrop

Preferences – Internet Accounts

Preferences -Disk Encryption

AddressBook

iCal

iCal

DashBoard

Mail

LaunchPad

Expose

Linked lists, hash tables, big O notation, search algorithms, bitwise operations…
Everything on paper.
It’s kinda hard! And I have to say I felt stupid some times…

But they said I did well. So I’ll have to wait for an answer.
Whatever happens, it’s already amazing that Apple contacted me, and wanted to interview me here in Barcelona.

Now I’ll enjoy my stay here, till sunday, having champagne on my private deck in the hotel.
Cheers!

On Friday, I’ve got a meeting with Apple. Job interview with 3 iOS engineers managers, plus a recruiter.
Cross your fingers! California is just past the sea… ; )

It will only include Apache 2, MySQL 5.1, and PHP 5.3.
Only one virtual host will be available by default (but you can still tweak the configuration files).

No log file viewing, no configuration editing, no OpenLDAP, no easy website creation and management, no SCM…
But it will be free. : )

Now, I just need to finish writing the documentation, for the application and on the website, take a decision for the pricing, and it will be over…

I probably won’t have time to finish everything this week, as I’m flying to Barcelona for the Mobile World Congress.
But maybe next week… Stay tuned!

The main purpose of WebStart is to provide you with a workable web and database server.
Therefore, it includes the Apache 2 HTTP server (with the PHP scripting language), the MySQL database server, and the OpenLDAP directory service.

But WebStart is more than just a packaged version of those software. It also provides you with a full-featured web development environment, with more than 50 useful tools, that web developers often need.

It has software for automatic image generation, software revision control, document conversion, automated documentation generation, testing, etc.

All that stuff is installed in a specific directory, separate from the system paths, so you don’t have to worry when you upgrade your Mac OS X system. It does not replace any exisiting software on your computer. It’s just here at your convenience, so you can concentrate on your development tasks, rather than on compiling and installing software again and again from scratch.

At the opposite, I always felt completely stupid with RISC processors. From the PPC architecture, with all that vectorial and floating point registers, to the ARM architecture, know used on the iOS devices.

I took a closer look on the ARM architecture some time ago, because I always felt the need to know more about RISC processors.

Here are a few tips, or things that I’ve learned about the ARM architecture.

First of all, an ARM processor can be run in several modes, as Intel processors.
The six available modes are:

1. User: The unprivileged mode under which most tasks run
2. FIQ: Entered when a high priority interrupt is raised
3. IRQ: Entered when a low priority nterrupt is raised
4. Supervisor: Entered on reset and when a interrupt instruction is run
5. Abort: Memory access violations
6. Undef: Undefined instructions mode

I must say I always felt bad with RISC registers. There are just too many of them.
The ARM architecture has 37 registers. All registers are 32 bits long.

The registers are:

1. 1 program counter
2. 1 current program status register
3. 5 saved program status registers
4. 30 general purpose registers

However, access to these registers are defined by the CPU mode.
Each mode has access to 13 general purpose registers (r0 – r12), a stack pointer (r13), a link regiser (r14), a program counter (r15), and the current program status register (cpsr).

When running supervisor mode, the spsr (saved program status register) register is also available.

The ARM architecture does not support shift operations, but they can be done through multiplication, by a power of 2.

It’s also important to note that the ARM architecture is a «load & store» architecture, meaning memory to memory data processing is not available.
Data need to be copied into registers first, and then processed.

So stay tuned, I’m now concentrating on that…

Sometimes, while coding, it may be difficult to decide whether to use a recursive function or a loop, and if so, what kind of loop.
The best example, is the factorial computation. That example is typically used to teach recursive function.

I always felt something strange with those examples. Why the hell using a recursive function for a factorial computation, since we can use a while loop, for instance?

If you think about machine code, or assembly, calling a procedure implies to copy the values of some registers (instruction pointer, etc), to execute a jump into another portion of memory (maybe in another segment), to execute the code, to restore the registers, and finally to return to the previous memory location (RETF).
In pure assembly, a simple loop, using the CX register, on Intel, is far more efficient, as there’s no jump, nor stack operation to copy the register values.

So what about C? Take a look at this typical example:

The same can be achieved with a while loop:

We can also choose to use a for loop:

In pure assembly, we would also write a loop. So with GCC inline assembly:

Which one will be the fastest? At first sight, I would have said inline assembly, while, for, and finally the recursive function.

But that’s not the case.
Running each case 10000000 time gives the following results:

Inline assembly is the fastest, but the recursive function is very very close.
The while and for loops takes much longer.

I was very surprised. Why such results?
The answer is in the way GCC optimizes to source code to generate intermediate object code.

If we take a look closer at what GCC does, we can see it optimizes for us a lot of things.

For instance, our recusrisve function, in pure assembly, generated by GCC:

And now the while loop:

The same applies for the for loop.

We can see here the compiler (GCC for instance) did a HUGE optimization of our source code.
It means actually that, except if you’re a assembly genius, you probably won’t code that will run faster, because you did it with inline assembly.
Nowadays, compilers are so efficient that some optimizations just won’t work.

In doubt, always remember to benchmark your code, and always remember that compiler can usually generate intermediate assembly code, so you can check what your code will really look like, when executed by the CPU.

At first sight, it may seem it’s hard to code with those settings, but it really saves you a lot of time debugging your app.
Most of the problems usually encountered in application development, using Objective-C, comes from the Objective-C runtime. And sometimes, those problems are hard to debug, because of the dynamic nature of the Objective-C language.

Activating most of the compiler error flags will save you time, as the compilation will fail, with an error message, instead of leaving you with a app that crashed for apparently no reason.

About the “Unused Parameters” setting, if you really don’t use a parameter, you can cast it to void, so the compiler won’t complain:

When dealing with methods returning an id type, you may sometimes have to cast the object, to let the compiler knows about the type:

So here are the settings, grouped as in the XCode build settings panel.

Linking

Dead Code Stripping

DEAD_CODE_STRIPPING = YES

Activating this setting causes the -dead_strip flag to be passed to ld(1) via cc(1) to turn on dead code stripping.
If this option is selected, -gfull (not -gused) must be used to generate debugging symbols in order to have them correctly stripped.

[DEAD_CODE_STRIPPING, -dead_strip]

Link With Standard Libraries

LINK_WITH_STANDARD_LIBRARIES = YES

If this setting activated, then the compiler driver will automatically pass its standard libraries to the linker to use during linking.
If desired, this flag can be used to disable linking with the standard libraries, and then individual libraries can be passed as Other Linker Flags.

[LINK_WITH_STANDARD_LIBRARIES, -nostdlib]

Packaging

Info.plist Output Encoding

INFOPLIST_OUTPUT_FORMAT = binary

Specifies the output encoding for the output Info.plist (by default, the output encoding will be unchanged from the input). The output endcodings can be ‘binary’ or ‘XML’.

[INFOPLIST_OUTPUT_FORMAT]

GCC 4.2 – Code Generation

Generate Debug Symbols

GCC_GENERATE_DEBUGGING_SYMBOLS = NO

(Permitted for «Debug» configuration)
Enables or disables generation of debug symbols.
When debug symbols are enabled, the level of detail can be controlled by the build ‘Level of Debug Symbols’ setting.

[GCC_GENERATE_DEBUGGING_SYMBOLS]

Generate Position-Dependant Code

GCC_DYNAMIC_NO_PIC = YES

(No permitted for «Debug» configuration, or for shared libraries)
Faster function calls for applications. Not appropriate for shared libraries (which need to be position-independent).

[GCC_DYNAMIC_NO_PIC, -mdynamic-no-pic]

Inline Methods Hidden

GCC_INLINES_ARE_PRIVATE_EXTERN = YES

When enabled, out-of-line copies of inline methods are declared ‘private extern’.

[GCC_INLINES_ARE_PRIVATE_EXTERN, -fvisibility-inlines-hidden]

Make Strings Read-Only

GCC_REUSE_STRINGS = YES

Reuse string literals.

[GCC_REUSE_STRINGS, -fwritable-strings]

Objective-C Garbage Collection

GCC_ENABLE_OBJC_GC = Unsupported

Compiles code to use Garbage Collector write-barrier assignment primitives within the Objective-C runtime.
Code is marked as being GC capable.
An application marked GC capable will be started by the runtime with Garbage Collection enabled.
All Objective-C code linked or loaded by this application must also be GC capable.
Code compiled as GC Required is presumed to not use traditional Cocoa retain/release methods and may not be loaded into an application that is not running with Garbage Collection enabled.
Code compiled as GC Supported is presumed to also contain traditional retain/release method logic and can be loaded into any application.
Garbage Collection is only supported on Mac OS X 10.5 and later.

[GCC_ENABLE_OBJC_GC, -fobjc-gc | -fobjc-gc-only]

Optimization Level

GCC_OPTIMIZATION_LEVEL = Fastest, Smallest [-Os]

• None: Do not optimize. [-O0]

  With this setting, the compiler’s goal is to reduce the cost of compilation and to make debugging produce the expected results.
  Statements are independent: if you stop the program with a breakpoint between statements, you can then assign a new value to any variable or change the program counter to any other statement in the function and get exactly the results you would expect from the source code.
• Fast: Optimizing compilation takes somewhat more time, and a lot more memory for a large function. [-O, -O1]
  
With this setting, the compiler tries to reduce code size and execution time, without performing any optimizations that take a great deal of compilation time. In Apple’s compiler, strict aliasing, block reordering, and inter-block scheduling are disabled by default when optimizing.
• Faster: The compiler performs nearly all supported optimizations that do not involve a space-speed tradeoff. [-O2]
  
With this setting, the compiler does not perform loop unrolling or function inlining, or register renaming.
  As compared to the ‘Fast’ setting, this setting increases both compilation time and the performance of the generated code.
• Fastest: Turns on all optimizations specified by the ‘Faster’ setting and also turns on function inlining and register renaming options.
  This setting may result in a larger binary. [-O3]
• Fastest, smallest: Optimize for size.
  This setting enables all ‘Faster’ optimizations that do not typically increase code size.
  It also performs further optimizations designed to reduce code size. [-Os]

[GCC_OPTIMIZATION_LEVEL]

GCC 4.2 – Language

C Language Dialect

GCC_C_LANGUAGE_STANDARD = C89

(C99 permitted if absolutely necessary, especially on iOS)
Choose a standard or non-standard C language dialect.

• ANSI C:
  Accept ISO C90 and ISO C++, turning off GNU extensions that are incompatible. [-ansi]

  Incompatible GNU extensions include the ‘asm’, ‘inline’, and ‘typeof’ keywords
 (but not the equivalent __asm__, __inline__, and __typeof__ forms), and the ‘//’ syntax for comments.

  This setting also enables trigraphs.
• C89:
  Accept ISO C90, but not GNU extensions. [-std=c89]
• GNU89:
  Accept ISO C90 and GNU extensions. [-std=gnu89]
• C99:
  Accept ISO C99, but not GNU extensions. [-std=c99]
• GNU99:
  Accept ISO C99 and GNU extensions. [-std=gnu99]
• Compiler Default:
  Tells the compiler to use its default C language dialect. This is normally the best choice unless you have specific needs. (Currently equivalent to GNU89.)

Please see the full GCC manual for the full definition of all these settings on the C dialect:

http://developer.apple.com/documentation/DeveloperTools/gcc-4.2.1/gcc/C-Dialect-Options.html

[GCC_C_LANGUAGE_STANDARD]

GCC 4.2 – Warnings

Check Switch Statements

GCC_WARN_CHECK_SWITCH_STATEMENTS = YES

Warn whenever a switch statement has an index of enumeral type and lacks a case for one or more of the named codes of that enumeration.
The presence of a default label prevents this warning.
Case labels outside the enumeration range also provoke warnings when this option is used.

[GCC_WARN_CHECK_SWITCH_STATEMENTS, -Wswitch]

Effective C++ Violations

GCC_WARN_EFFECTIVE_CPLUSPLUS_VIOLATIONS = YES

Warn about violations of the following style guidelines from Scott Meyers’ Effective C++ book:

• Item 11:
  Define a copy constructor and an assignment operator for classes with dynamically allocated memory.

• Item 12:
  Prefer initialization to assignment in constructors.

• Item 14:
  Make destructors virtual in base classes.

• Item 15:
  Have operator= return a reference to *this.

• Item 23:
  Don’t try to return a reference when you must return an object.

and about violations of the following style guidelines from Scott Meyers’ More Effective C++ book:

• Item 6:
  Distinguish between prefix and postfix forms of increment and decrement operators.

• Item 7:
  Never overload &&, ||, or, .

If you use this option, you should be aware that the standard library headers do not obey all of these guidelines; you can use grep -v to filter out those warnings.

[GCC_WARN_EFFECTIVE_CPLUSPLUS_VIOLATIONS, -Weffc++]

Four Character Literals

GCC_WARN_FOUR_CHARACTER_CONSTANTS = YES

Warn about four-char literals (e.g., MacOS-style OSTypes: ‘APPL’).

[GCC_WARN_FOUR_CHARACTER_CONSTANTS, -Wfour-char-constants]

Global Construction or Destruction Required

GCC_WARN_ABOUT_GLOBAL_CONSTRUCTORS = YES

Warn about namespace scope data that requires construction or destruction, or functions that use the constructor attribute or the destructor attribute.
Additionally warn if the Objective-C GNU runtime is used to initialize various metadata.

[GCC_WARN_ABOUT_GLOBAL_CONSTRUCTORS, -Wglobal-constructors]

Hidden Local Variables

GCC_WARN_SHADOW = YES

Warn whenever a local variable shadows another local variable, parameter or global variable or whenever a built-in function is shadowed.

[GCC_WARN_SHADOW, -Wshadow]

Implicit Conversion to 32 Bit Type

GCC_WARN_64_TO_32_BIT_CONVERSION = YES

Warn if a value is implicitly converted from a 64 bit type to a 32 bit type.

[GCC_WARN_64_TO_32_BIT_CONVERSION, -Wshorten-64-to-32]

Incomplete Objective-C Protocols

GCC_WARN_ALLOW_INCOMPLETE_PROTOCOL = YES

Warn if methods required by a protocol are not implemented in the class adopting it.
Only applies to Objective-C and Objective-C++.

[GCC_WARN_ALLOW_INCOMPLETE_PROTOCOL, -Wno-protocol]

Inhibit All Warnings

GCC_WARN_INHIBIT_ALL_WARNINGS = NO

Inhibit all warning messages.

[GCC_WARN_INHIBIT_ALL_WARNINGS, -w]

Initializer Not Fully Bracketed

GCC_WARN_INITIALIZER_NOT_FULLY_BRACKETED = YES

Warn if an aggregate or union initializer is not fully bracketed.

Example, Here initializer for a is not fully bracketed, but that for b is fully bracketed.

[GCC_WARN_INITIALIZER_NOT_FULLY_BRACKETED, -Wmissing-braces]

Mismatched Return Type

GCC_WARN_ABOUT_RETURN_TYPE = YES

Causes warnings to be emitted when a function with a defined return type (not void) contains a return statement without a return-value.
Also emits a warning when a function is defined without specifying a return type.

[GCC_WARN_ABOUT_RETURN_TYPE, -Wreturn-type]

Missing Braces and Parentheses

GCC_WARN_MISSING_PARENTHESES = YES

Warn if parentheses are omitted in certain contexts, such as when there is an assignment in a context where a truth value is expected, or when operators are nested whose precedence people often get confused about.
Also warn about constructions where there may be confusion to which if statement an else branch belongs.
Here is an example of such a case:

In C, every else branch belongs to the innermost possible if statement, which in this example is if (b) .
This is often not what the programmer expected, as illustrated in the above example by indentation the programmer chose.
When there is the potential for this confusion, GCC will issue a warning when this flag is specified.
To eliminate the warning, add explicit braces around the innermost if statement so there is no way the else could belong to the enclosing if.
The resulting code would look like this:

[GCC_WARN_MISSING_PARENTHESES, -Wparentheses]

Missing Fields in Structure Initializers

GCC_WARN_ABOUT_MISSING_FIELD_INITIALIZERS = YES

Warn if a structure’s initializer has some fields missing.
For example, the following code would cause such a warning, because “x.h” is implicitly zero:

This option does not warn about designated initializers, so the following modification would not trigger a warning:

[GCC_WARN_ABOUT_MISSING_FIELD_INITIALIZERS, -Wmissing-field-initializers]

Missing Function Prototypes

GCC_WARN_ABOUT_MISSING_PROTOTYPES = YES

Causes warnings to be emitted about missing prototypes.

[GCC_WARN_ABOUT_MISSING_PROTOTYPES, -Wmissing-prototypes]

Missing Newline At End Of File

GCC_WARN_ABOUT_MISSING_NEWLINE = YES

Warn when a source file does not end with a newline.

[GCC_WARN_ABOUT_MISSING_NEWLINE, -Wnewline-eof]

Multiple Definition Types for Selector

GCC_WARN_MULTIPLE_DEFINITION_TYPES_FOR_SELECTOR = NO

Warn if multiple methods of different types for the same selector are found during compilation.
The check is performed on the list of methods in the final stage of compilation.
Additionally, a check is performed for each selector appearing in a "@selector(...)" expression, and a corresponding method for that selector has been found during compilation.
Because these checks scan the method table only at the end of compilation, these warnings are not produced if the final stage of compilation is not reached, for example because an error is found during compilation, or because the -fsyntax-only option is being used.

[GCC_WARN_MULTIPLE_DEFINITION_TYPES_FOR_SELECTOR, -Wselector]

Nonvirtual Destructor

GCC_WARN_NON_VIRTUAL_DESTRUCTOR = YES

Warn when a class declares an nonvirtual destructor that should probably be virtual, because it looks like the class will be used polymorphically.

[GCC_WARN_NON_VIRTUAL_DESTRUCTOR, -Wnon-virtual-dtor]

This is only active for C++ or Objective-C++ sources.

Other Warning Flags

WARNING_CFLAGS = -Wall -Wextra -Werror -Wbad-function-cast -Wmissing-declarations -Wmissing-prototypes -Wnested-externs -Wold-style-definition -Wstrict-prototypes -Wdeclaration-after-statement

Space-separated list of additional warning flags to pass to the compiler. Use this setting if Xcode does not already provide UI for a particular compiler warning flag.

[WARNING_CFLAGS]

Overloaded Virtual Functions

GCC_WARN_HIDDEN_VIRTUAL_FUNCTIONS = YES

Warn when a function declaration hides virtual functions from a base class.

[GCC_WARN_HIDDEN_VIRTUAL_FUNCTIONS, -Woverloaded-virtual]

For example, in:

the A class version of f() is hidden in B, and code like this:

will fail to compile. This setting only applies to C++ and Objective-C++ sources.

Pedantic Warnings

GCC_WARN_PEDANTIC = YES

Issue all the warnings demanded by strict ISO C and ISO C++; reject all programs that use forbidden extensions, and some other programs that do not follow ISO C and ISO C++.
For ISO C, follows the version of the ISO C standard specified by any -std option used.

[GCC_WARN_PEDANTIC, -pedantic]

Pointer Sign Comparison

GCC_WARN_ABOUT_POINTER_SIGNEDNESS = YES

Warn when pointers passed via arguments or assigned to a variable differ in sign.

[GCC_WARN_ABOUT_POINTER_SIGNEDNESS, -Wno-pointer-sign]

Prototype Conversion

GCC_WARN_PROTOTYPE_CONVERSION = NO

Warn if a prototype causes a type conversion that is different from what would happen to the same argument in the absence of a prototype.
This includes conversions of fixed point to floating and vice versa, and conversions changing the width or signedness of a fixed point argument except when the same as the default promotion.
Also, warn if a negative integer constant expression is implicitly converted to an unsigned type.
For example, warn about the assignment "x = -1" if “x” is unsigned.
But do not warn about explicit casts like “(unsigned) -1″.

[GCC_WARN_PROTOTYPE_CONVERSION, -Wconversion]

Sign Comparison

GCC_WARN_SIGN_COMPARE = YES

Warn when a comparison between signed and unsigned values could produce an incorrect result when the signed value is converted to unsigned.
This warning is enabled by -W, and by -Wall in C++ only.

[GCC_WARN_SIGN_COMPARE, -Wsign-compare]

Strict Selector Matching

GCC_WARN_STRICT_SELECTOR_MATCH = YES

Warn if multiple methods with differing argument and/or return types are found for a given selector when attempting to send a message using this selector to a receiver of type “id” or “Class”.
When this setting is disabled, the compiler will omit such warnings if any differences found are confined to types which share the same size and alignment.

[GCC_WARN_STRICT_SELECTOR_MATCH, -Wstrict-selector-match]

Treat Missing Function Prototypes as Errors

GCC_TREAT_IMPLICIT_FUNCTION_DECLARATIONS_AS_ERRORS = YES

Causes warnings about missing function prototypes to be treated as errors.
Only applies to C and Objective-C.

[GCC_TREAT_IMPLICIT_FUNCTION_DECLARATIONS_AS_ERRORS, -Werror-implicit-function-declaration]

Treat Nonconformant Code Errors as Warnings

GCC_TREAT_NONCONFORMANT_CODE_ERRORS_AS_WARNINGS = NO

Enabling this option will downgrade messages about nonconformant code from errors to warnings.
By default, G++ effectively sets -pedantic-errors without -pedantic; this option reverses that.
This behavior and this option are superseded by -pedantic, which works as it does for GNU C.

[GCC_TREAT_NONCONFORMANT_CODE_ERRORS_AS_WARNINGS, -fpermissive]

Treat Warnings as Errors

GCC_TREAT_WARNINGS_AS_ERRORS = YES

Enabling this option causes all warnings to be treated as errors.

[GCC_TREAT_WARNINGS_AS_ERRORS, -Werror]

Typecheck Calls to printf/scanf

GCC_WARN_TYPECHECK_CALLS_TO_PRINTF = YES

Check calls to printf and scanf, etc., to make sure that the arguments supplied have types appropriate to the format string specified, and that the conversions specified in the format string make sense.

[GCC_WARN_TYPECHECK_CALLS_TO_PRINTF, -Wno-format]

Undeclared Selector

GCC_WARN_UNDECLARED_SELECTOR = YES

Warn if a "@selector(...)" expression referring to an undeclared selector is found.
A selector is considered undeclared if no method with that name has been declared before the "@selector(...)" expression, either explicitly in an @interface or @protocol declaration, or implicitly in an @implementation section.
This option always performs its checks as soon as a "@selector(...)" expression is found, while -Wselector only performs its checks in the final stage of compilation.
This also enforces the coding style convention that methods and selectors must be declared before being used.

[GCC_WARN_UNDECLARED_SELECTOR, -Wundeclared-selector]

Uninitialized Automatic Variables

GCC_WARN_UNINITIALIZED_AUTOS = YES

Warn if a variable might be clobbered by a setjmp call or if an automatic variable is used without prior initialization.
Detection of uninitialized automatic variable requires data flow analsys that is only enabled during optimized compilation.
Note that GCC cannot detect all cases where an automatic variable is initialized or all usage patterns that may lead to use prior to initialization.

[GCC_WARN_UNINITIALIZED_AUTOS, -Wuninitialized]

Unknown Pragma

GCC_WARN_UNKNOWN_PRAGMAS = YES

Warn when a #pragma directive is encountered which is not understood by GCC.
If this command line option is used, warnings will even be issued for unknown pragmas in system header files.
This is not the case if the warnings were only enabled by the -Wall command line option.

[GCC_WARN_UNKNOWN_PRAGMAS, -Wunknown-pragmas]

Unused Functions

GCC_WARN_UNUSED_FUNCTION = YES

Warn whenever a static function is declared but not defined or a non-inline static function is unused.

[GCC_WARN_UNUSED_FUNCTION, -Wunused-function]

Unused Labels

GCC_WARN_UNUSED_LABEL = YES

Warn whenever a label is declared but not used.

[GCC_WARN_UNUSED_LABEL, -Wunused-label]

Unused Parameters

GCC_WARN_UNUSED_PARAMETER = YES

Warn whenever a function parameter is unused aside from its declaration.

[GCC_WARN_UNUSED_PARAMETER, -Wunused-parameter]

Unused Values

GCC_WARN_UNUSED_VALUE = YES

Warn whenever a statement computes a result that is explicitly not used.

[GCC_WARN_UNUSED_VALUE, -Wunused-value]

Unused Variables

GCC_WARN_UNUSED_VARIABLE = YES

Warn whenever a local variable or non-constant static variable is unused aside from its declaration.

[GCC_WARN_UNUSED_VARIABLE, -Wunused-variable]

Warn About Deprecated Functions

GCC_WARN_ABOUT_DEPRECATED_FUNCTIONS = YES

Warn about the use of deprecated functions, variables, and types (as indicated by the ‘deprecated’ attribute).

[GCC_WARN_ABOUT_DEPRECATED_FUNCTIONS, -Wno-deprecated-declarations]

Warn About Undefined Use of offsetof Macro

GCC_WARN_ABOUT_INVALID_OFFSETOF_MACRO = YES

Unchecking this setting will suppress warnings from applying the offsetof macro to a non-POD type.According to the 1998 ISO C++ standard, applying offsetof to a non-POD type is undefined.
In existing C++ implementations, however, offsetof typically gives meaningful results even when applied to certain kinds of non-POD types. (Such as a simple struct that fails to be a POD type only by virtue of having a constructor.)
This flag is for users who are aware that they are writing non-portable code and who have deliberately chosen to ignore the warning about it.
The restrictions on offsetof may be relaxed in a future version of the C++ standard.

[GCC_WARN_ABOUT_INVALID_OFFSETOF_MACRO, -Wno-invalid-offsetof]

It allows to browse through the whole iPhone file system, displaying files and directories, with infos and previews.
I doubt such an app will be validated by the AppStore team, but who knows.

I had to re-create the project with the new XCode 4, because it was created for iOS 2.
Now it’s also ready for a future iPad version.

If it’s not validated, I think I’m going to release the source code as OpenSource…

More on a few days…

Informations about siege can be found here: http://www.joedog.org/

Don’t know yet when this will be released, but stay tuned… : )

PropEdit has been updated to version 1.0.1:
Download page

ConsoleGrowl has been updated to version 1.2.2:
Download page

No new feature. Those new releases contains only minor bugfixes.

You can download it from the eosgarden’s website for now, but the app has been submitted to MacUpdate and to the Mac AppStore as well.

Enjoy!

I highly recommend it to anyone, developers and designers. John Maeda is at the exact frontier of both worlds, touching excellence…
He present’s what simplicity really is, or sould be, with ten laws to achieve it.

The ten laws are:

1. Reduce
   The simplest way to achieve simplicity is through thoughtfull reduction.
2. Organize
   Organization makes a system of many appear fewer.
3. Time
   Savings in time feels like simplicity.
4. Learn
   Knowledge makes everything simpler.
5. Differences
   Simplicity and complexity need each other.
6. Context
   What lies in the peripheral of simplicity is definitively not peripheral.
7. Emotion
   More emotions are better than less.
8. Trust
   In simplicity we trust.
9. Failure
   Some things can never be made simple.
10. The one
    Simplicity is about subtracting the obvious and adding the meaningful.

Each law is described with a pictogram by John Maeda.
I created some wallpapers with those pictos. They are now displayed each minute on my desktop, remembering me about simplicity, and the need to achieve it, whenever possible.

You can download the wallpaper set from here. But just don’t forget to read this book!

ASL consists of routines providing an interface to the Apple System Log facility, which is intended to be a replacement for the SysLog API.
It allows client applications to create flexible, structured messages and send them to the syslogd server, where they may undergo additional processing. Messages received by the server are saved in a data store (subject to input filtering constraints).

A man page for ASL can be found here: ASL

Here’s a example C implementation:

For now, I won’t implement the malloc() set of functions in the C library, because I haven’t implemented the brk and mmap system calls.
Doing this would surely be fun, but right now I need to code some other kernel stuff.

So I decided to write a specific allocator for the Xeos kernel. This way, it will have it’s own allocator, managing it’s own memory region.
I guess it’s the best solution for now, to get things correctly done.

No surprise, this will be kmalloc().
This will save me a lot of time, and make the code more maintainable for later.

I’m also going to see if I can build LLVM for Xeos… I’m a bit tired of GCC, since Apple’s XCode 4… ; )

The traffic has indeed increased. About 300% more, based on Google analytics stats.
A few apps on MacUpdate, a few tweets about the apps, and badaboum… The server crashed.

So they told me (rudely) I had to switch to a VPS.
50 bucks more. Mmmm, swiss providers…

So I moved to a provider in France. Now I got a VPS, with Debian 5, for the same price as the shared server!
The provider is LWS. I have to say the service is great!

I’ve been contacted by a recruiter from Apple, asking me to send my resume.
Maybe California is not so far away after all!

It would be a great experience, both at the technical and human level.
Hope to be able to give more news on the next weeks…

By the way, the temperature is 19°c in Cupertino. Here, in Switzerland, it’s -2°c!!!

If you’re interested, here’s a link to my full resume.
Simply send me an email to get in touch!

Basically, it shows up the active processes, and adds the possibility to change to process nice value.
For those who don’t know what the nice value is, here’s the description from Wikipedia:

The name “nice” comes from the fact that the program’s purpose is to modify a process niceness value. The true priority, used to decide how much cpu time to concede to each process, is calculated by the kernel process scheduler from a combination of the different processes niceness values and other data, such as the amount of I/O done by each process.

The name “niceness” originates from the idea that a process with a higher niceness value is “nicer” to other processes in the system, as it allows the other processes more cpu time, by having a lower priority (and therefore a higher niceness) itself.

I needed that for a project, using ANSI-C. So I wrote it.

Here’s the code, maybe it can be helpfull for someone else… : )

I’ll write down here stuff related to the eosgarden’s activities, software development and releases, miscellaneous code related stuff, Mac & iOS development tips, etc.

For the curious, the name noxeos comes from the latin word for night (nox) and the greek word for dawn (eos).
I choosed it so it can represent the reverse face of the eosgarden website.

Anyway, thanx for reading this! : )