CProgrammingTrends

Popularity For Objective-C Has Stalled

Zach Walton — Thu, 25 Apr 2013 13:22:46 +0000

Traditional development trends has ensured that the C and C++ programming languages remain popular even decades after their creation. Despite being created in the same year as C++, Objective-C was never as popular. That all changed with the advent of the iPhone, but things are starting to slow down.

The TIOBE Programming Community Index, an index that charts the popularity of programming languages, has found that Objective-C’s popularity has stopped growing after its meteoric rise from rank 42 in 2008 to rank 4 in 2012.

Now, this doesn’t mean that the popularity of Objective-C will start to dramatically decrease. The popularity of iOS devices and Apple’s insistence that Objective-C be the only language used in iOS development ensures that the language will have a long life ahead of it.

We can always make a few assumptions based on these findings though. One is that iOS development isn’t growing as fast as it used to. Developers building apps for iOS will continue to do so, but this stall in growth seems to indicate that new developers are not flocking to the platform.

It could all change at a moment’s notice, however, especially if Apple does release a cheaper iPhone for emerging markets this year. The development communities in China, India and elsewhere could help catapult Objective-C to even greater heights as these teams scramble to get apps on the Apple App Store.

As for the other languages, the top eight languages didn’t see a rise or decline in popularity compared to last year. C remains the most popular with Java and C++ taking up second and third place respectively. As you already read, Objective-C is at the number four spot, and C# rounds out the top five.

Here’s the full chart showing the top 20 programming languages this month:

You can check out the rest of the stats including a list of the top 50 programming languages in the world over at the TIOBE Programming Community Index page.

Comments

Moost Goes Open Source Thanks To Last.fm

Zach Walton — Thu, 21 Feb 2013 13:38:15 +0000

Last.fm may be well known for its Internet radio services, but the company is also breaking into the open source scene. It’s latest release is sure to pleas all the C++ coders out there.

Last.fm’s Marcus Holland-Moritz announced today that moost, it’s C++ library is now available to all under an open source license. He says that moost has been in development by Last.fm’s MIR team over the past five years, and contains all the tools and utilities they use on the site. It’s based on the boost C++ libraries.

Moost contains a number of features that programmers will find handy. Here’s some of the features you can expect when using it:

There are a lot of different things in moost. Some are really simple, yet very helpful in day-to-day work, like the which template that allows you to use pairs (and containers storing pairs) more easily with standard algorithms; or stringify, a function template that turns complex objects into strings. Other parts are slightly more sophisticated: for example, moost contains the framework that is shared by all our backend services, and that allows you to write a daemonisable service with logging, a set of standard options and even a service shell that multiple users can connect to when the service is running, all in a few lines of code.

As our backend services are inherently multi-threaded, there’s also a bit of threading support in moost. For example, the safe_shared_ptr template is immensely useful for resources that are shared between threads and need to be updated atomically.

Moritz says that moost also features memory wrapped dataset classes and an abstraction for loading shared objects. Both of which will make it easier to manage resources while building out large datasets.

You can check out moost for yourself now over at GitHub. Moritz encourages any interested developers to contribute to the project if they have the time.

Comments

Robots Of The Future Powered By C++

Zach Walton — Thu, 01 Jan 1970 00:00:00 +0000

Developers and programmers use a variety of programming languages to get things done. C++ is one of the more complicated languages to learn, but its use can lead to some pretty amazing applications. For instance, the language is being used to power the dancing moves of one of the world’s most advanced robots- the CHARLI.

CHARLI was built by a team of researchers at Virginia Tech who wanted to develop “a research platform to study bipedal walking and autonomous behaviors for humanoid robots.” Such a task requires top of the line mechanical engineering as well as the programming required to make it all work.

For fun, the researchers decided to program some dance moves for CHARLI-2. Perhaps riding on the song’s success, they chose PSY’s Korean hit Gangnam Style. CHARLI-2′s performance isn’t an exact replication, but it’s impressive nonetheless.

For those interested in programming for robotics, there are a number of open source projects currently available. One of the more popular is OpenRAVE which focuses on “motion planning algorithms in real-world robotics applications.” It’s mostly used for arm movements, but you can still have a crazy dance party with just a robot’s arms.

It may not help your robot dance, but here’s some other open source C++ development platforms for robotics – Urbi and Orocos.

[h/t: Geek.com]

Comments

Traditional Programming Language Job Trends ? August 2012

Rob Diana — Thu, 01 Jan 1970 00:00:00 +0000

It is a little late, but it is time for the summer edition of the job trends for traditional programming languages. The languages in this update have not changed for a while as we are only looking at Java, C++, C#, Objective C, Perl and Visual Basic. Over the next few months, I will be looking at various languages to determine how this list and other job trends posts should change. Also, please review some of the other job trends posts to see if your favorite language is already in one of these posts.

First, we look at the job trends from Indeed.com:

Most of the job trends have declined in the past few months. Objective-C continues to show solid growth. C# had a significant drop but still leads its C++ cousin. Over the long term trends, Java and C# have very positive growth, while the other languages are tending to stagnate. There is huge growth in mobile development, especially with Objective-C leading the way in iOS development. C++ and Perl show slight declines, but still not too significant. Visual Basic continues its stable trend, showing an increase over the past 2 years but still a decline from 2005.

Now, let’s look at SimplyHired’s short term trends:

SimplyHired’s trends are show much more decline in recent months than Indeed. Interestingly, Objective-C is not showing much of a positive trend, but it is a much better trend than the other languages in the list. Java is showing a surprising decline over the past few months, but still retains a large lead over the other languages. C++ and C# show almost identical trends over the past year, with a decline in recent months. Visual Basic and Perl show similar declines to the other languages.

Finally, here is a review of the relative scaling from Indeed. This provides an interesting trend graph based on job growth:

Unsurprisingly, Objective-C has the most growth, but the growth has slowed since our last update. C# growth is solid, hovering around 100% for the past 3 years. Visual Basic and C++ continue to decline. Perl and Java are still showing signs of life, but the growth is not very significant.

What does all this mean? First, it is clear the iOS development is hot as is all mobile development. However, mobile development does not seem to be affecting Java or the growth of mobile is offsetting the decline of Java in the enterprise space. Why does Java (and some of the others) show relative growth, but not strong growth in the trend graphs? Basically, we are seeing that while some of the languages are still showing increasing job postings (the relative growth chart), the percentage of postings is less than before. So, other languages not in this list may be increasing in demand quicker than these traditional languages.

Comments

In July Objective-C Overtook C++, Thanks To Apple

Zach Walton — Thu, 01 Jan 1970 00:00:00 +0000

One of the more interesting things to look at each month is the TIOBE Index. It collects all the programming languages and lists the top 20 based on “skilled engineers world-wide, courses and third party vendors.” C and Java are usually battling for the top, but the third position fro July is definitely interesting.

The TIOBE Index has found that Objective-C has overtaken C++ in popularity. Objective-C was in sixth place in July of 2011 and has jumped to third this month. Apple can take most of the credit for the jump in Objective-C popularity.

As The Inquisitr explains, C++ and Objective-C were developed in the same year. Programmers flocked to C++, however, because it’s better in high-performance systems whereas Objective-C is better for light-weight systems. It was’t until 1988 when Steve Jobs ordered Objective-C to be used on the NeXTSTEP OS, which eventually led to OS X, that the language began to gain notoriety.

From there, Objective-C really took off when the iPhone launched. Apps built for the iPhone rely heavily on the Objective-C language and it shows. Moving three spaces up and overtaking C++ in just a year is a pretty impressive feat. As more people begin to develop for iOS, we should start to see Objective-C rise even more. Granted, it’s probably won’t overtake Java or C for a while as both of those languages are pretty engrained into the overall programming ecosystem.

Here’s the top 20 programming languages for July. There might be a few more surprises beyond Objective-C’s rise to fame such as Visual Basic .NET’s massive jump from 25th to 15th place.

Apple Helps Objective-C Overtake C++

Zach Walton — Thu, 01 Jan 1970 00:00:00 +0000

Here’s the top 20 programming languages for July. There might be a few more surprises beyond Objective-C’s rise to fame such as Visual Basic .NET’s massive jump from 25th to 15th place.

Basic Event-Based Programming

Dale Smith — Thu, 01 Jan 1970 00:00:00 +0000

One of the largest hurdles I have found both myself and others struggle with is learning to think in different ways to accomplish a task. We naturally try to do things in a systematic, linear way.

This is all well and good when telling a story, or making your plans for the day, or choosing what order to get things in the supermarket. But there is another way we think subconsciously- an event-based way, or reacting to the other things happening around us. We usually don’t realize we’re doing it, but it would be a bad day if we didn’t slow down at the intersection in our vehicles, or step over that wire dangling haphazardly across the office. Wouldn’t it be great if our programs could respond like that too?

One of my first forays into Object-Oriented Programming (OOP) was writing a very small, very basic game engine with Python, using the Pygame library. It wasn’t much- drawing the game board and player, with some arrow key movement. But it opened my eyes to a whole new method of writing programs, and understanding the why behind OOP, where with all the sequential programming we had done in my college classes, I didn’t understand the point.

The basic idea is this: Your program’s entry point will setup your base objects, probably some kind of managers. If we were writing a game engine for instance, we might initialize the screen, and user input devices. Then we start the ‘loop’, where on every clock cycle we would check all of our objects for tasks they need to do based on what’s happened in that clock cycle. So say the player in our game engine clicks the start button, in the code beneath our mouse manager would send the click event with coordinates to the main event manager. This event would then be re-broadcast to the rest of the resource management objects to do their own tasks. The UI manager would use the coordinates and find that the start button was clicked, firing an event that causes the game state to change to playing, prompting the screen manager to draw the game… you get the idea.

So how do we setup such a system? Luckily I have some code handy to outline a very basic example.

This is C++ compiled working on Ubuntu Linux 11.10 with g++. For ease of display on this site, I have compiled all the classes into one file. As the classes expand, splitting them up into .h and .cpp files is a must.

//First our basic includes #include #include #include


using namespace std;
//Define our base classes that everything else will inherit from
//Base Event class - this is needed so we can send many types of events to all objects

class Event {

public:

    Event() {

        this->type = "Generic Event";

    }

    virtual string getType() {

        return this->type;

    }

private:

    string type;

};
//Base Object class - this will parent our manager objects so we can store them in a vector together

class Object {

public:

    virtual void recv(Event *event){};

};
//Event Manager: This is where the magic happens

class EventManager : public Object {

public:

    //When objects are initialized they will be passed the EventManager object's pointer. They then

    //call registerObject with themselves as the parameter

    int registerObject(Object *object) {

        this->objects.push_back(object);

    }

    //When something happens, an Object will call broadcast with the appropriate event, which will

    //then be sent to all other objects via a recv() method.

    void broadcast(Event *event) {

        for(int i = 0; i < this->objects.size(); i++) {

            this->objects[i]->recv(event);

        }

    }

private:

    vector objects;

};
//This event will be fired each clock cycle - this acts as a 'ping' to objects like a mouse or keyboard

//manager so they can check if any input is pending

class TickEvent : public Event {

public:

    TickEvent() {

        this->type = "Tick Event";

    }

    string getType() {

        return this->type;

    }

private:

    string type;

};
//This is our 'Ticker', the object that will start the whole thing

class Ticker : public Object {

public:

    Ticker(EventManager *EM) : Object() {

        this->em = EM;

        //Here you can see the Ticker object being registered with the Event Manager

        this->em->registerObject(this);

    }

    //Once everything is setup in our main, we call run() to start the process

    void run() {

        while(true) {

            //On each loop we send a tick event to the event manager

            this->em->broadcast(new TickEvent());

        }

    }

    //A basic example of a registered object receiving events- here we parse out tick events and

    //could do different things depending on which event we actually do get.

    void recv(Event *event) {

        if((*event).getType() != "Tick Event") {

            //Do something on events other than ticks

        }

    }

private:

    EventManager *em;

};
//This is an optional class I like to add that we can later disable for real-time debugging

class Debugger : public Object {

public:

    Debugger(EventManager *em) : Object() {

        this->em = em;

        this->em->registerObject(this);

    }

    //For now we simply cout the name of events as they come in- without parsing the tick events

    //out, we see a LOT of ticks. Once more objects have been added we would watch for specific

    //Events instead of catching them all

    void recv(Event *event) {

        cout << (*event).getType() << endl;

    }

private:

    EventManager *em;

};
//And finally, our entry point. We setup the main objects and run the program.

int main(int argc, char** argv) {

    EventManager* EM = new EventManager();

    Ticker* CPU = new Ticker(EM);

    Debugger* Bug = new Debugger(EM);

CPU->run(); return 0; }

So there it is in a nutshell, this could easily be separated into multiple class files and be used in a real application with the help of a UI library, and some input. But that is beyond the scope of this article. Maybe next time.

C++ IDEs ? Too many to choose from

Dale Smith — Thu, 01 Jan 1970 00:00:00 +0000

When I started my C++ class in college last year, the first thing we (the students) were required to do, was to find an IDE for the class. After some configuration headaches the professor made it standard for us all to use the same one, but it didn’t suit everybody’s tastes. With so many out there, it’s hard to find one to objectively label as the “best” but with some tips, maybe I can set you on the way to picking one that suits you.

The IDE that was made standard in my programming class was Netbeans 7.1. The IDE is cross platform, and easy to configure if you run anything other than Windows. Us Windows users had a very long and complicated tutorial to follow on the class website for getting Netbeans to work, which only then worked half the time as the tutorial was written for version 6.9 of Netbeans. Netbeans does not come packaged with a compiler, causing all of the above headaches.

As far as general usability when you do get it configured though, Netbeans is one of my favorite IDEs to work with. It has a large support base for a variety of languages, with syntax highlighting, easy refactoring, and version control built in. It generates make files by itself, so you don’t have to edit it every time you add or remove a file from your project. It also has a plugin system that allows you to extend the base IDE just about any way you want. Netbeans is free and open source.

One of the IDE’s that several students showed up to class using was Bloodshed’s Dev-C++. It is saddening to see how popular this IDE still is; probably only because it is a relatively small download, and is bundled with a compiler, making the configuration non-existant. However, the IDE has not been updated in a long time. In fact, looking at the git repository where the code is hosted, it has not had a single code change since 2005. It does not feature a debugger, or any kind of syntax highlighting. It may have been up to date when it released, but there are other, much more feature-full solutions out there, that are also free. I would stay away from Dev-C++.

An IDE I have been hearing about more often here recently is Code::Blocks. While I have not used it myself, it touts a large feature set, while looking much more lightweight than others. In fact, I would compare it closely with Netbeans; like Netbeans it does not ship with a compiler, is open source, and extensible through plugins. It has syntax highlighting, code completion, smart indenting, and a fully featured debugger. It even has a neat to-do list built in for you to keep track of where you are in large projects. It is cross platform like Netbeans, but is written in C++, compared to Netbeans which is written in Java, so it should perform better on slower systems. I will definitely be giving it a try on my next project, you should too.

Of course we can’t talk about C++ IDEs without mentioning Microsoft Visual Studio. Although if you are an open-source kinda person like I am (why are you using this IDE anyway in that case), you will take offense at the newest version of Visual Studio, as Visual Studio 11 Express will only allow development of Windows 8 Metro apps. Thats right, to develop standalone Windows applications you will need to shell out $499 for Visual Studio 11 Pro. Visual Studio is a decent IDE, with lots of support for developing Windows applications, but I know I will not be using it any more unless I am specifically writing a Metro app. Not when there are other solutions that function just as well, if not better, and are not only free but open source.

Whether you are an experienced developer or just getting started, whichever IDE you decide to use, keep it updated and keep an ear to the ground for new ones with bigger, better features. The tech world is evolving so fast that we can’t afford to be left behind.

Visual Studio 11 Release Candidate Updated After User Feedback

Zach Walton — Thu, 01 Jan 1970 00:00:00 +0000

We reported back in February that Microsoft launched the Visual Studio 11 beta for developers to try ou and give their thoughts before the actual product launch. Microsoft says that there has been “significant” community response to the beta and so they are introducing some changes to the user interface to satisfy the needs of the community.

The community feedback for the Visual Studio 11 beta has been corralled into three key areas:

An overall desire for more visual “energy” and contrast
Calls for a more balanced application of Metro styling
A desire for greater icon clarity and differentiation through the use of color

To that effect, Microsoft has made some significant changes to Visual Studio 11 for the release candidate version. The company has provided before and after comparisons to show the changes that were made.

Visual Studio 11 Beta

Visual Studio 11 RC

The first problem was there was not enough color. Many users complained that everything was too gray. To that end, they have taken steps to colorize more of the components that developers will work with. Apparently colorize means turning everything blue, but blue and gray are a nice combination. The other change is bringing more colors to the status bar to denote different statuses from development to debug mode.

Since Visual Studio 11 is likely to launch alongside Windows 8, Microsoft has been applying the Metro style to the interface in the form of using all caps for the tool window titles. These have been returned to normal with only the top level menu items going all caps for greater emphasis.

To better fit into the Metro style, Microsoft has also created a new window chrome. No longer will there be a blue border around the window to denote the OS namesake. Now the entire window is the same color to bring the entire thing together. I find it more aesthetically pleasing, but some are sure to disagree.

Probably the biggest change introduced in the Visual Studio 11 beta was the removal of color from icons. This obviously created some confusion for similar looking commands since color is a great way to tell these apart. Microsoft has heard the complaints and will be adding color back to select commands.

Color is also being added back into the icons within the Solution Explorer, IntelliSense and the application icons. This should make everything more readable and easier to distinguish.

It’s obvious that Microsoft cares about their users by making these important changes to Visual Studio 11. There’s still more work to be done though before the official launch sometime this year. If you have yet to download it, check out the Visual Studio 11 beta and keep sending your feedback.

Comments

C Is Currently The Most Popular Programming Language

Zach Walton — Thu, 01 Jan 1970 00:00:00 +0000

Have you heard of the TIOBE Programming Community Index? It’s a table that lists the ratings of programming languages and tracks their status throughout the developer ecosystem. It’s a good indicator of where a language stands in terms of its general use. April has a few surprises though.

It was found that Java is a downward trend from it’s top spot in the developer world. It would appear that C is now the most popular programming language in the world at a rating of 17.555 percent. It’s not all that bad for Java though since it’s rating for April is at 17.026 percent. TIOBE Software says that Java will never diminish too badly due to the Android development scene.

How does TIOBE find these results? Here’s how the Web site puts it:

The TIOBE Programming Community index is an indicator of the popularity of programming languages. The index is updated once a month. The ratings are based on the number of skilled engineers world-wide, courses and third party vendors. The popular search engines Google, Bing, Yahoo!, Wikipedia, Amazon, YouTube and Baidu are used to calculate the ratings. Observe that the TIOBE index is not about the best programming language or the language in which most lines of code have been written.

What’s interesting is that C-based languages make up the majority of the top five list with C++ coming in at number three with a rating of 8.896 percent, Objective-C at number four with 8.236 percent and C# at number 5 with 7.348 percent. Objective-C has seen the largest climb with its position at number eight this time last year.

While Java may be doing down, JavaScript is working it’s way up rather slowly. It was at number 10 this time last year, but now it’s at number nine.

TIOBE hopes that their list will help developers make the proper choice when it comes to building new applications. Choosing a more popular language will ensure maximum compatibility, but there are applications being made now that should make language conversion easier for those who want to program applications in multiple languages.

Here’s the top 20 languages for the month of April according to the TIOBE Index:

[h/t: Slashdot]

Comments