Assuming that I'm willing to invest in Vala, I noticed that using under a typical GNU/linux distribution is relatively easy and productive especially when creating GUIs, the question is: what I can do with this language and GTK-stuff under other platforms ?
There aren't really any cross-platform issues inherent to Vala, so what you really need to concern yourself with is GLib and GTK+ (if you want to using).
GTK+ (and GLib/GObject/GIO) do support Windows; there are 32-bit and 64-bit packages available. There is also support for OS X. Windows and OS X support historically haven't been as solid as Linux but there are applications like Inkscape, GIMP, and Wireshark, which have GTK+ UIs and work on Windows and OS X.
Related
It is known that wxWidgets uses native APIs for a native look.
This seems not to be the case for GTK+.
Is this still the case or something have changed?
Why GTK+ cannot use the native API in Windows?
My understanding is that GTK+ is just a program while wxWidgets is a group of programs (one for each OS). While GTK+ uses libraries like GObject to achieve portability, wxWidgets was built from scratch in each specific platform. Is this correct?
Please, provide detail like what API is using GTK+ in Windows and what API is using wxWidgets instead.
Thank you.
wxWidgets uses native Win32 API for drawing and for UI, i.e. various controls in wxWidgets are the native Windows Shell controls when running under Windows.
GTK+ still uses some low-level Win32 API to be able to run under Windows at all, but it uses its own controls which it draws itself using its own drawing library too.
Both GTK+ and wxWidgets are libraries and not programs and both contain platform-independent and platform-specific code, although wxWidgets has much more (proportionally speaking) of the latter than GTK+.
When deploying software (particularly non managed code), obviously you are targeting an OS as well as a particular archtecture. However, when downloading software on the internet, architecture never seems to be relevant beyond 32-bit and 64 bit (presumably x86 and x86-64). Is this because there is an inherent assumption that most desktop computers run some flavor of x86 and get their software from the web while mobile devices that have ARM processors get their software from mobile stores, etc? I feel this is too big of an assumption.
That is not an assumption but manifestation of resource limitation on the developers part.
Porting software even to another operating system requires substantial amount of work because you have to make sure that your interface remains consistent. Porting to another architecture has many more implications.
Proprietary software belongs to some organisation which works for profit. So from their perspective it’s not worth the effort to port their software to a less used OS let alone a different architecture. For example photoshop is widely used but still it’s windows and Mac only because adobe doesn’t see any benefit in porting to Linux.
As for the free software which supports different architecture you will always find some link to binaries or the source.
In summary we can say that if you developed a new architecture why would other people write software for that until of course it becomes something like x86 or arm.
Can anyone suggest or recommend development tools or documentation for writing graphical applications on the Acorn RISC OS on the Raspberry PI? This OS is newly supported on the Raspberry PI computer, and I would like to be able to write graphical applications for that OS. It is however quite hard to identify working tools for the version on PI, given the long history of RISC OS, the (multiple) incompatible revisions of the OS, and relatively scant resources for RISC OS on PI.
One set of development tools bundled on the official RISC OS SD card image is the Charm high level programming language.
There is an implementation of the Lua scripting language available too, with extensions to integrate with the WIMP GUI environment.
The RISC OS Programmers reference manuals provide details of the available SWI's (API's).
If your happy with using the inbuilt BBC BASIC and / or ARM assemblers, open a text editor of your choosing (I used to like Zap) and simply Google for BBC BASIC wimp and pick a tutorial e.g. Beginners Guide to WIMP Programming OR Wimp Programming on RISC OS
If you wish to play in something other than BBC Basic or ARM assembler, RISC OS open sell a USB stick with assorted compilers and a set of DDE (Desktop Dev Environment) tools, which I assume are PI compatible. Unfortunately the few high level GUI based development tools, such as Helix Basic won't work on the PI.
Raspberry Pi RISC OS System Programming Revealed by Bruce Smith looks pretty good covering BBC BASIC, ARM Assembly and some C. It includes some WIMP development.
Also, check out the Documents folder on the Raspberry Pi RISC OS release. There should be a subfolder to do with programming which contains an introduction to BBC BASIC and the developer's guide to WIMP programming mentioned in #arober11's answer above. I think there are a couple of sample programs included as well.
I'm working with some C/C++ code that runs on Win32 and also VxWorks. It uses #ifdef WIN32 to switch to platform specific implementations.
I've been using the code on the iPhone and I want to update it and keep it as portable as possible, but I'm not sure what's the best practice. So far I've been using #ifdef __APPLE__ blocks.
What should I be using to target Apple iPhone and Mac OS X?
Is #ifdef __APPLE__ the best approach?
Are there any gotchas to be aware of?
You might look at __IPHONE_OS_VERSION_MIN_REQUIRED to partition code for different versions of iOS. You might also look at partitioning based on CPU, e.g. between 32- and 64-bit Intel apps.
Is there any iphone ARM based decompiler available?
You might have some luck with Ida Pro. It's kind of expensive though. I'm not sure if it has ARM support, but OllyDbg generally does well for my windows project.
(I just looked at it, and OllyDbg doesn't support ARM, but I'm leaving the link because it's still a great program.)
Ida Pro is the disassembler, it translates the binary into human readable ARM assembler.
hex-rays also provides a real decompiler, which translates the disassembled code into C.