It is undeniable that there are a lot of open-source projects out there on the internet that make our life and our work a lot easier. From a small utility that help our repeatable tasks done a lot faster, to a great framework that sit inside many applications. Yet there are still many developers that never contribute their software to open-source community.

Develop an open-source project can be done in many different ways. For example, you can develop a small extension to the software you work with or make a new software that help solve other people’s problems. With a project like this, you can learn many aspect of software development as you extends the functionalities of your software over time.

Here are the 6 points I have got from develop my own open-source projects that help me learn and improve my knowledges in the software development field.

1. You know what is the problem and how to solve it.

When you develop a software, you should already know what problems that your software is solving and how to solve it. When you starts a new project, you will see how many problems that software can help and how feasible to develop a software to solve it. Eventually, you may find a problem that leads you to a software that can be a viable product for your potential company.

2. You learn how software works in different environments with real users.

With real users, you can see how your software works across different of things like Operating System, Devices, Internet Connections or even your software itself for example, the compatibility of your software. You may find yourself that your software still solve the problems for them or not just by looking at how is your software grow.

3. You know how your software stand on the (free) market.

Even though your software is great, many people do not heard of your software if you do not do anything to spread the words. Or if you are not the “marketing guy” like me, you will see how your software rank up purely by its functions.

Show your software in the right place at the right time can make a huge different directly to yourself. Your software could be the best one to solve that particular problems over night.

4. You learn how to improve your software.

With open-source software, anyone can contribute to the project. While you can learn from someone else’s project, you may find your users send you a feedback on your project or even help contribute to it. User feedbacks are a great things in the software development that help grow your software even further.

5. You learn how your software structure works with other developers.

In contrast to users, if someone contribute to your project, you may see how your project structure works when they get their hands on. Moreover, you can learn by code review from their contribution to see how they write their code upon this kind of structure.

6. You learn how much your documentations help your users.

Your user growth is also affected by your documentations. If your software is great but your documentation is poor, surely not everyone will know how your software works from the thin air. Making a good documentation also help you on reviewing your code on the later day.

Develop an open-source software gives us a lot of knowledges that we can use in our future software projects or even in current project we are working on. Furthermore, if we all contribute to open-source community, there will be a lot of learning resources, examples, frameworks and tools that help the world a lot better.

With the limited time of development, the application deployment can take a lot of our precious time over the year. I decided to improve this flow by automated the process from building, archiving and deploy to the various deployment environment. With the help of fastlane tools and my iOSDeploy script, I can deploy the application with a push of my finger.

In order to automated the project deployment, fastlane’s gym and iOSDeploy must be installed. Both can be install using the command (within the project directory)…

sudo gem install gym
git clone https://github.com/spywhere/iOSDeploy iosdeploy

After installation finished, in the project directory would look like this…

Fastlane’s gym will be our build tool and iOSDeploy will be our deployment tool. If you already have your own build tool, you could only install iOSDeploy and any build configurations in this post could be skipped.

Next, before we configure the project, we have to setup the first run of iOSDeploy. Make sure you already have Dropbox app with Full Dropbox access (no need to be a production one) ready and then run…

After setup, you should see a .iosdeploy file created within your project directory (this file then can be shared to your co-worker to let them deploy the application without need to setup it again).

In order to test the setup, I have export the .ipa file to output folder and run…

As you can see at the bottom of the screen, a direct URL to the Dropbox file which generated by iOSDeploy (I will show you how it looks like later in the post).

Now we know that the deployment is successfully setup, next step we will automated the build, archive and deployment process by configure our project.

To make our deployment simpler by automated the process, first we need to add a new target…

Since my target is not going to build anything by Xcode (we use fastlane’s gym), I will choose Aggregate target type instead (you could use any of the target type, it is just my project not required for any particular target type).

I will named it “Deploy Example App” to make it easy to understand…

Now you should see your target showing up on the left hand side of the editor, next step is to configure the target.

We will add a Run Script Phase in the Build Phases tab, for me I will also add another Run Script Phase to build and archive the project using gym.

And now we should be ready to deploy our application, fully automated.

To deploy our application, switch the target to a newly created target…

And just build the project. We should see the message show that our build is success.

And that is it, we just deploy our application.

Now on the user side, when they want to install the application, simply send them an URL which generated by iOSDeploy. When they open, they should see a page similar to this one…

When they want to install application, just hit the Install button and the device will ask them to install…

And they now can run the application…

When you deploy another build, the iOSDeploy will regenerate the page that the latest build will be on top of the page.

And that is how the automatic deployment works with fast lane’s gym, iOSDeploy and Dropbox.

In my recent post, I promised that I will show you how I design a programming language for my own uses. And here it is!

The first iteration of language design is pick a language name. Personally, I love how things named by their parent name based on the real world. Take a look at Apple for example, their company name “Apple” with some of their product name “Macintosh”, which is one of apple varieties, mimics how the real world object are named.

My company name is consists of a word that means particle, so the language should be named with something tiny as a particle, so I come up with “Quark” but the concept of quark is too complicated to me, so I pick “Atom” instead. More over, Atom source code will be compiled into “Molecule” byte code since many atoms bond together into molecule, hence the name.

Before starting the language design, I want a language to be easy to link into 3rd-party programs (game engine in my case). So the language should be scripting language that has small footprint on the language itself and more power on the standard library for standalone application instead.

The decision behind “compiled to byte code” rather than “REPL (read-eval-print-loop)” is I really want the Atom program to be modifiable without recompile the whole system again (thinking about Runtime Virtual Machine. Same machine, different programs). Still, Atom language allows program to use Atom internally without compile to byte code since the language suite is consists of language components. You could use Atom language parser to give you an abstract syntax tree of the language and compile it yourself, or send it immediately to a “Molecule” virtual machine inside your program to run it.

The next iteration is a bit out of focus, I immediately write down my (ideal) language sample, just to see an overview of the language. Send it to my friends and see if they like it or not. And here is the first sample of the language in that iteration.

The feedback from my friends are positive, they like how the language is minimal but give the familiar look. The language inspired a lot from Python with a bit of Swift and C. The only intention of the language that shared until these day is the typing speed (which is why I love Python so much). The language (at that moment) aims to be easy to implement, which is why the code block still there and there are only one-line if all around.

Then the next iteration comes, I starts by writing “the language principles”, a set of goals to keep the language on the line. The first three “principles” of the Atom language are…

• Language should allows developers to write code faster and can be picked up easily.
• Language should be able to link with 3rd-party engine in a few steps as possible.
• Language should be flexible enough to extends its functionalities.

So, I refine the language to be object-oriented by introduced a concept of class into the language (inspired by Java), which is why the keywords and the annotations are borrowed. Additionally, I also remove the need of semicolon after each conditional statement, to make it easier to type.

Once the language is stable enough, I take a time to thinking about standard library that ship with the language itself and spark on the data collection types. In whitespace insensitive language (such as Objective-C or JavaScript), arrays and dictionaries can be wrote within one line. This conflicts with my language principle as it harder to read one line declaration of array or dictionary, so I gather some examples from various languages including YAML. Finally, I decided to use indentation based for the array and dictionary declaration, and here is the first version of it.

Now comes the keywords or no keywords part, as I try different language designs I comes up with an idea about “Why we need keywords?” since the first time I write computer program, I always wonder about English keywords “Why programming language does not exists in my native language?”. So I try reduce the keywords, make them into two versions (with and without keywords), send to even more friends and let them see if they like what they see or not.

Gladly, they did like the keyword version since that change my perspective about keywords a lot. So the language principles are changed by aims for easy to read, easy to write and that gives me the really clean look of the language.

The latest version until this date (December 2015), make it even more cleaner. Again with YAML, Atom language now use indentation with dashes and colons to create a list, set and dictionary. Colons are bring back as a required part to give more context on the code block. Conditional statements and loops are reduce the need of parenthesises and use Python-style statement to increase the typing speed. And more such as…

• “let” keyword, optionals and string interpolation. All inspired by Swift.
• Lambda, assignment destructuring and variable arguments. All inspired by ECMAScript 6
• List comprehensions and overall look of the language. All inspired by Python (version 3 to be specific)

There are some parts of the language need to be refine but the language design process are quite fun. Just like drawing, you keep imagine how your language would look like and give them a shot, may be you can see how small things can be a big part of your design.

In my recent project, I want to create a high-level computer language that compile to byte-code, aim to be a highly flexible language extension, fast to write and easy to read. Keywords play a huge part of the language design I have come to think about, especially on the fast to write and easy to read goal.

Many computer languages have keywords, they are used to express the programming logic in a way we are comfortable with. But why we need it? Doesn’t it make us a lot easier to use a natural-language-independent computer language? Let’s take a look.

In C and their family languages, most of the keywords are shared the same meaning which make us comfortable when we switch to another C family language. Here is the example program in Java-like language which I will use to illustrate the different language design I come across (please note that the language is a design concept and might or might not be implement in practice).

When I thinking about the idea of fast to write language, the first thing that comes to my mind is less code. Sure, without keywords, the language will be a lot shorter and can be express in a line or two. Take a look at the no-keyword version of my language below.

You can see how the language can be changed upon the natural language you currently use today. Every single name can be changed into whatever you feel like to use.

Seem nice? Turn out, it is not that good when come to the typing speed. You can see how each punctuation express the logic but most of them have to press the Shift key in order to type those characters, this takes a lot of time to type when come to the large program.

Now, let’s take a look at an updated version of the previous language. This time I add the keywords back.

Okay, it a lot easier to write this time but we have trade the speed of typing with some limitations of the language. We could implement the language to have no reserved words but keywords (What is the difference between “keyword” and “reserved word”?). Surely, it can use any word for the name of things but take a look at this line of code.

You can see how frustrating the code can be read, not to mention the ambiguity of the expression.

So, how can we implement it? Well, just take a step back and think about “What are the language goals?” instead of “How the language will looks like?”. We design a language to be fast to write and easy to read, so the keywords and reserved words in a language are acceptable which come to the only design that pass the rules, the keyword version.

But still, there are room for the improvements, since we design the language to be easy to read and fast to write, not easy to read and fast to process. We could design the language to use indentation as a block of code, this way we reduce the number of lines and also make the language faster to write. Just like how YAML can express the object much shorter than JSON.

Now take a look at the final design of the language.

That seems a lot better both to read and to write. But doesn’t it seem a bit familiar? Python? Take a look at Python version.

Surely it does seems like Python a lot, just only some colons and class declaration being omitted. But why another language? Well, Python is a great language but it is overpower for the task. And if you looks closely, you can see how my language express the class by the whole file rather than multiple declarations in the same file. Just like Java but with Python syntax.

But that only a glimpse of the language I designed. The language features are a lot more with the influences from various languages such as Java, Python, Swift or even ECMAScript 6. I will write the update once I got the language fully functional, ready and proven to be implemented later on.

Apple provides an easy, Xcode friendly continuous integration system within their ecosystem called OS X Server. OS X Server is an operating system which contains multiple services for managing and serving the clients (such as User Directory, Mails, Messaging and more!). One of the interesting service OS X Server provided is Xcode Server. Xcode Server serves as a continuous integration server for iOS projects which supports both Unit Testing and UI Testing on both simulators and actual devices, additionally Xcode Server also serves as a Git remote server in which hold the project source codes in a unified place.

Once the server is setup, client can creates, run and see the testing result from an automated testing configurations called Bot, right in the Xcode.

Configure the iOS project for testing in the Xcode Server is also easy, if your project can be built and run in the Xcode, then it can also build and run on the testing environment on the Xcode Server. No further configuration needed, save a lot of our time!

Once the testing configuration is setup, the bot will be run according to the configuration. Each testing session, called Integration, consists of collecting the source code, building, testing and also collecting the output from the project (such as iOS app bundle) along with the testing results.

With these results, the team can identify and solve the problem right away. Increase the software quality and reduce the shipping time while maintain the cost on the same level.

OS X Server can be downloaded for free in the OS X section if you have an Apple developer program or $19.99 on the Mac App Store.