Fernando Bevilacqua

Past the Event Horizon - Why "AI Replacing Developers" Is the Wrong Frame

2025-01-11T00:00:00+00:00

In June 2025, Sam Altman published a blog post titled “The Gentle Singularity,” in which he made a declaration that would have sounded insane just three years prior: “We are past the event horizon; the takeoff has started”. To the uninitiated, this summons images of science fiction—robots walking the streets or a sudden, dramatic rupture in reality. Yet, as Altman noted, the world looks largely the same. Commuters still sit in traffic; we still use Jira; and the physical constraints of the universe remain stubbornly in place.

But for those of us in software engineering, the shift has been anything but gentle. We stand at the intersection of three contradictory narratives:

Barriers to entry have collapsed, leading to “Vibe Coding” where natural language replaces syntax.
Labor demand has cratered, with US job postings falling to pre-pandemic lows.
The developer population is exploding, driven by global adoption and AI integration.

The capability-to-cost curve has shifted. The real question now is: how do we integrate this tool into what we already know about building software—without fooling ourselves with demo-driven thinking?

This post is an attempt to do that, grounded in the latest labor signals, developer-population data, and a critical “third axis” that many discussions ignore: verification cost (and why most GenAI projects still fail).

1) Abstraction doesn’t erase developers — it changes what “developer work” means

A useful historical analogy is the compiler. Before its usage in scale, software was handcrafted on the binary level (or very close to it). As the abstraction improved, developers stopped caring about (or paying attention to) the generated, low-level code. The higher the abstraction (programing languange, paradigm, etc), the less we look down the chain.

We don’t spend much time today arguing “compiled vs interpreted”, or about the “perfect assembly” in the way people did decades ago. That’s because most teams now operate at a higher layer of abstraction. Following that analogy, today’s Java code is the abstraction, not its bytecodes. Same for C, for instance: most of the time (not always, but very significantly) you don’t look at the generated assembly code. It’s simply too low level.

In that sense, compilers or interpreters didn’t eliminate developers; they made it cheaper to create software. That dynamic tends to increase demand. You can see this in how the developer population grew alongside each major abstraction wave.

Evidence: the pool keeps growing

Contradicting the narrative of “AI replacing humans” is the relentless growth of the global developer population. According to SlashData’s Developer Nation surveys, the number of developers has nearly doubled in four years:

Q3 2021: 28.8 Million
Q3 2023: 38.9 Million
Q3 2025: 48.4 Million

The image below shows the progression:

Source: SlashData

Takeaway: If AI reduces the “cost per unit of software,” the most historically consistent outcome is more software, not less (the Jevons Paradox). More importantly, that very software still needs to be designed, operated, secured, audited, and maintained—i.e., the parts of the job that aren’t “just code.”

2) The labor-market chart needs context: the COVID spike distorts the story

The FRED/Indeed chart below is often used to prove the “collapse” of the industry. But it requires context.

Source: FRED/Indeed

What the curve actually says:

There was a major run-up during the COVID-era boom (the peak visually dominates the chart).
Then a sharp decline as interest rates rose and the “growth at all costs” era ended.
After 2024, the series looks closer to stabilization, and by late 2025 it shows slight upward drift (e.g., 68.30 on 2025-12-12).

If you anchor on the COVID spike, you’ll read everything after as “collapse.” If you treat that spike as an outlier boom, the post-2024 pattern reads more like a market finding a new baseline.

However, this stabilization hides a qualitative shift. We are witnessing the decoupling of “coding” from “employment.” While the demand for full-time, US-based W-2 engineers has contracted, the population of people building software has exploded.

3) The Rise of “Vibe Coding” and Theory Loss

If the quantitative shift is about numbers, the qualitative shift is about method. We have entered the era of “Vibe Coding.”

Popularized by Andrej Karpathy, Vibe Coding describes a workflow where the human acts as a director rather than a mason. You don’t write loops; you “vibe” with the LLM. You paste a screenshot and say, “Make it look like this but pop more.” You describe intent, and the machine generates syntax.

This was made possible by the rapid commoditization of AI models. Using Claude Opus 4.5 today, for instance, is something impossible to think of (or explain) 10 years ago. It is important to stress that this way of working is in the hands of those who can affort tokens. Also they are gatekept by the FANGS of the world.

Open-source models, however, are improving at neck-breaking speed. As shown below, models like Vicuna-13B quickly reached 92% of ChatGPT’s quality, collapsing the moat between proprietary and open tools.

Source: Vicuna

If we bring the chinese massive progress regarding AI, specially in the open-source scene, things become even more interesting. As DeepSeek-V3 states in its README:

DeepSeek-V3 stands as the best-performing open-source model, and also exhibits competitive performance against frontier closed-source models.

The power of open-source is already stablished in software development. It is paving the same way regarding AI. The famous Google’s Leaked “No Moat” Memo warned the company about that. The memo noted that open-source models were achieving results comparable to Google’s with significantly less time and capital investment. “Open-source models are faster, more customizable, more private, and pound-for-pound more capable”.

Regardless of the model, be it a paid or an open-source one, its usage has very low friction now. It clearly helps the development and production of software, so it becomes an inflection point. It is simply too slow to create something without AI from now on.

The Danger: Theory Loss

But this ease of generation brings a hidden risk: Theory Loss.

Peter Naur’s classic 1985 essay “Programming as Theory Building” argues that a program is not its source code. A program is a shared mental construct (a theory) that lives in the minds of the people who work on it.

Old World: You built the theory by struggling with the syntax.
New World (Vibe Coding): The AI generates the code. If you merely “approve” it without struggle, the mental model is never formed in your mind.

The software becomes a “zombie”: it works, but no one knows why or how to change it safely. This leads us to the central economic friction of the AI era.

4) The “new axis”: 95% of GenAI pilots fail — and verification cost is why

In a recent Forbes piece covering MIT research, the framing is blunt: 95% of custom GenAI tools fail to cross the pilot-to-production cliff.

Why? Because of the Verification Tax.

Generative AI is confidently wrong. If a model is 95% accurate, you still have to check 100% of its work to find the 5% of errors. The economic formula for AI adoption isn’t just about speed.

When systems are confidently wrong, people accumulate “Trust Debt.” They spend more time forensic-checking the AI’s output than they would have spent writing it themselves.

The Technological Response: Why TypeScript Won

This explains a startling statistic from GitHub’s Octoverse 2025: In August 2025, TypeScript overtook Python to become the #1 language on GitHub.

Why? Because Types are the automated payment of the Verification Tax. In a world where AI generates millions of lines of code, humans can no longer verify it all by reading. We need automated guardrails. TypeScript’s static type system rejects invalid code before it ever runs, preventing the AI from “hallucinating” artifacts that don’t exist. It turns the “Vibe” into a contract.

Additionally, types and interfaces are ground theory for any system. A seasoned software engineer can plan and architect using type-defined contracts that the AI will follow. This was good practice before AI-driven development, now it is a requirement.

5) Humans + AI beats either alone (and this is where “ROI” actually comes from)

So, how do we fix the failure rate? The answer lies in pairing.

OpenAI’s recent white paper on productivity impacts (GDPval) should be treated as part of the “human+agent pairing” evidence base. The research highlights that big gains appear when AI and experts work together, not when you try to replace humans outright.

On the Stack Overflow podcast, Pete Johnson (Field CTO, AI at MongoDB) reinforced this, noting that the “job killer” framing is flawed. He argues:

“You still own it… You’re still responsible for it running in production.”

Synthesis: The best ROI story is not “replace people,” it’s:

Reduce cycle time on well-defined tasks (drafting).
Keep experts responsible for correctness and system-level coherence (verification).
Reinvest the productivity gains into more software and better operations (Jevons Paradox).

Every serious, corporate-grade line of code needs caring beyond text. For instance, systems still need customer feedback loops, support, investiment, decisions. It’s naive to belive that when you replace all developers with AI equivalents, you can just say:

“Oh, that’s wrong because of my AI. I am sorry, it will fix it”

You can’t say that specially when your software causes financial (or human) losses. Someone still has to “sign” and respond for it. Are C-class executives ready to fire all developers then take the fall for absolutely everything? I doubt it.

6) The JetBrains lens: some categories shrink, others expand

JetBrains’ Developer Ecosystem data reframes the workforce as a portfolio of activities, not just “dev count.” With ~20.8M professional developers in 2025, the work is redistributing.

My read of the likely shift:

Fewer people needed in “first-draft” tasks (boilerplate, rote CRUD scaffolding, basic docs).
More people needed in tasks that scale with output volume and risk:
Evaluation & Testing: Building the “Accuracy Flywheels” that catch AI errors.
Platform Engineering: Managing the infrastructure for 10x more services.
Security & Compliance: Auditing the black box.
Domain-Heavy Product Engineering: The “Theory Building” that AI cannot simulate.

This is the same “abstraction expands the surface area” dynamic—except now the abstraction is probabilistic and requires verification.

7) Final claim: If software eats the world, AI makes it hungrier

Software development is coordination across stakeholders (execs, product, support, legal, ops). If AI starts to mediate all of those interfaces—writing specs, drafting contracts, generating runbooks, then society doesn’t become less dependent on engineers.

It becomes more dependent on the people who can design, integrate, and operate AI-enabled systems end-to-end, with accountability.

The engineers of the future will not be those who can prompt the fastest, but those who can verify and plan the deepest.

What leaders should do

Finally some not-requested ideas for the future.

Treat GenAI as a system, not a feature. Budget for evaluation, monitoring, and workflow redesign.
Engineer for the verification tax. Make uncertainty explicit; build feedback loops (“accuracy flywheel”).
Adopt “Safety-First” languages and tooling. The rise of TypeScript is a signal: use tools that automate verification.
Pair AI with accountable experts. The “human + AI” combination is where gains compound.
Measure transformation, not logins. Pilot success is redesign + adoption in real workflows, not just chat usage.

Additional Resources

Note

This text has been edited by me and mostly written by AI models. I provided the ideas, my notes, the links to fetch information (which I have consumed myself previously) and the narravite I wanted. I iterated on the final text for quite some time. I also wrote parts of the text myself.

My year 2019 in review

2020-01-07T00:00:00+00:00

The year 2020 is upon us already. Since barely a week has passed in this new year, I think it is a good time to reflect on the previous year. If I were to summarize 2019 in a single word, it would be atypical.

I honestly can’t remember a year where so many different things happened. Both regarding my personal life and the world. Since it is out of my scope to discuss the problems of the world here, I will keep the focus on myself.

I finished my PhD

After 3.3 years of work, on November the 19th of 2018, I defended my thesis. I was awarded the title of PhD in Information Technology. The title was granted by the Univesity of Skövde, in Skövde, Sweden.

Technically my defence is outside 2019, but it is somehow connected. Doing a PhD is a three-headed beast that takes more than you can actually perceive. I moved from Brazil to Sweden with my wife in April 2015. It was the very first time we left Brazil to live abroad. I can confidently say that those years living in Skövde were beyond what I had bargained for. It was amazing to know the Swedish culture, meet people from all over the world and get to see the fantastic Scandinavia.

While doing my PhD, my work was delightful. Despite the inherent unknowns of any research work, everything else was great. A lot of fikas (Swedish coffee break) with colleagues and friends. Coding, learning new things, evolving as a professional and independent researcher. I have nothing but a warm thank you to say about that.

Hard landing?

Right before Christmas in 2018, I flew back home (to Brazil). January and February are the vacation period in Brazil, so I had a well-deserved break to clear my head. In March, I resumed my duties at the Federal University of Fronteira Sul (UFFS). After literally years without teaching, I was assigned 3 courses as main responsible.

As a curious fact, I received the news about my teaching duties and courses of 2019 at the end of 2018. It was the very same day I received the printed copies of my thesis. Quite a plot twist.

The going back to teaching or my old duties were never a problem. I like to work. Above all, I like challenges. I returned from a PhD with abnormal energy to change the world and everything.

As a result of that, I signed up to be the next coordinator of the Undergraduate Program on Computer Science at UFFS, effectively April 2019. Should I have waited for that step? Sure. Could I have waited? No, I could not. I have to admit that the academic environment is quite heavy sometimes. Not having a PhD in academia is like being a woodworker and not having your own tools. You might have the competence, the will and the means, but somehow the system fights against you. Additionally, if you are a younger person, that’s even more complicated. That might be my personal view of the whole thing, but that’s how I felt back then.

Having finished my PhD, for the first time in my career, I felt I had my own tools. This time I could not only move the wheel, but I could also very well destroy it if the spinning was not my liking. And that thought burned vividly in my head. Looking back now, I think I was more eager to prove myself (or others?) that I could actually make the difference. That could be seen as fuel by most people, but I was not counting on something else.

The OCD hits

When I was about 9 years old, I suffered from severe Obsessive-Compulsive Disorder (OCD). Back then, my life was significantly disturbed by it. After some time, however, and without medical help, it all went away. This time, however, it did not go away. On the contrary, it has grown out of control. From 2015 to 2018, that OCD demon slowly evolved in me again. Ironically, right after I had finished my PhD and rested during vacations, the OCD became unbearable. Around April and May, I was literally afraid to leave my house.

OCD is a heavy burden. It is always there, in an ever-growing vortex of anxiety. I reached a point that I thought the university would prevent me from teaching. I was also tormenting all those around me, particularly my wife. I finally admitted defeat and sought out a psychiatrist.

Changing the world is hard

I started taking medicine for OCD. Slowly, things improved over time. However, I had signed up for the coordination of our CS program. Hence my stress and anxiety levels were always on the roof. I was constantly thinking I was not doing enough or well enough. I was being unpolite (to say the least) with people to ensure things would move the way I thought were right.

Having studied human emotions in my PhD, I should know better that human beings are complicated animals. Anything that has people in it is complex by nature. We have different dreams, fears and goals. It is tough to align all thoughts under the same light.

I had managed teams before. I had worked with lots of different people in the past. But this time I had too much energy and too little patience. And above all, I was not willing to tolerate any academic behaviour that I once allowed.

The result? Friction all over the place, anxiety crisis, and so on. A colleague even asked me once if “it was really worth it to do all this I was doing at the cost of my own health and friends”. Burning bridges almost as my main job.

Shallow rate for open-source contributions

I want to add that my contributions to open-source projects, including my own, e.g. Flixel Studio and cvui, have reached their lowest rate ever. I literally had no time or will to work on them. My everyday routine was draining all my energy.

Differently from 2017 and 2018, where I significantly contributed to open-source, 2019 has been quite slow. Even after receiving a donation from the awesome Haxeflixel community to work on Flixel Studio (thank you very much!), I was not able to focus. That made me feel incredibly guilty and not worth the investment. Luckily the Flixel community and the people behind the project are great to lift contributors.

Anything good?

Yes, definitely! Lots of nice things happened, but I don’t think they quite fit in here. I mainly wanted to document how my 2019 gravitated. I am very thankful for all the great things that happened in 2019, like helping bootstrap a podcast and being invited to be the paranymph for our 2019 class.

I am working towards making 2020 a less intense, but more productive year. Less stress and fire, more applied energy and well being. That’s all. So long and thanks for all the fish, 2019.

cvui 2.7.0 is out! OpenCV GUI in Python

2019-02-16T00:00:00+00:00

I am pleased to inform that version 2.7.0 of cvui is out! cvui is a simple UI lib built on top of OpenCV drawing primitives.

This release contains bug fixes and the addition of a pure Python implementation of cvui, i.e. cvui.py. The Python port of cvui has been conceived and developed with the aim of achieving a 1-to-1 match regarding the already existing C++ API. As a consequence, functions and parameters names were kept the same, so existing C++ documentation should apply to Python with minor changes.

From now on, all computer vision developers out there working with Python can add UI components to their applications in an extremely easy way. The Python port of cvui is available via PyPy, so it is a pip command away. Just run:

pip install cvui

and you are ready to go. As simple as cvui itself.

cvui.py also aims to be a “header-only” file, so all you have to do is add it to your project if you are not using any package manager. Here is a simple example of the Python usage of cvui:

import numpy as np
import cv2
import cvui

WINDOW_NAME = 'CVUI Test'

cvui.init(WINDOW_NAME)

# Create a frame
frame = np.zeros((200, 400, 3), np.uint8)

while True:
    # clear the frame
    frame[:] = (49, 52, 49)

    # render a message in the frame at position (10, 15)
    # then show it on the screen
    cvui.text(frame, 10, 15, 'Hello world!')
    cvui.imshow(WINDOW_NAME, frame)

    if cv2.waitKey(20) == 27:
        break

All code examples are now also available in Python. The C++ version of cvui makes heavy use of parameters overloading, which is a problem in Python. To ensure good documentation and proper code auto-completion for cvui in Python IDEs, cvui.py has several dummy/wrapping functions. They have a proper list of arguments instead of a single *args parameter. It should provide a good user experience without causing any problems.

Finally, I would like to highlight the addition of new code examples, particularly the ui-enhanced-* ones. They show how to improve existing cvui components, e.g. make a window movable and minimizable. Documentation pages have also been tweaked to accommodate information regarding the newly added Python support.

Below is a list of changes according to the CHANGELOG. Thank you to all contributors that have helped improve cvui!

Added

Python implementation of cvui, i.e. cvui.py (read more)
Python examples ported from the already existing C++ ones.
New ui-enhanced-* examples, e.g. moving settings window (#41, #36, help from Amaury Bréhéret and ShengYu).
Cmake option ADD_PYTHON_EXAMPLES to control the build of Python examples (read more).

Changed

Documentation tweaks (help from ShengYu and Akash Kumar Singh).
Cmake version 3.1 or higher is now required to build the examples.
Cmake files were improved.
rect() color filling now supports alpha values, e.g. 0x7700ff00 (blue with 50% transparency) (#39, help from Justin Muncaster).

Fixed

rect() issue related to opacity (#42, help from Justin Muncaster).
Conflict with dirent.h and min()/max() macros on Windows (#38, help from Ali Zarei).

The rule of five projects

2018-07-21T00:00:00+00:00

Side projects are a great way to learn new technologies, to exercise what you already know or to just challenge yourself a bit. Usually a side project is not connected to a contract or backed by financial support, so there is no real pressure to actually finish them. As a consequence, the landscape becomes something like the following very quickly (at least for me):

Source: Commitstip - side projects

This great strip by Commitstip perfectly illustrates the life cycle of side projects. If you are like me, you have seen this scene way too many times: you have an idea, you start the project, things look and feel great. Then you pass the initial barrier where the creative work lives and you are left with non-creative, boring work to do. And sadly those tasks that remained are required to actually bring the project to life instead of creating yet another draft or handicapped prototype.

I got really sick of having ideas without implementation, or having half-baked and unfinished projects lying around. To end that problem once and for all, I came up with the rule of five projects (see below). It is very simple: use the energy and motivation of starting a new project as the fuel to actually finishing on-going ones. It’s like following a contract, but you are the contractor and the contractee.

I’ve been using the rule of 5 projects and it indeed prevented the creation of new side projects. More impressively, it helped me ship old side projects that were dormant, e.g. Codebot. It blew my expectations!

The rule of five projects

At any given time, you are allowed to have at most 5 (five!) side projects, which can be under development or on-going.

Note: for obvious reasons, anything that is related to your regular job does not count towards those 5 slots, unless you get paid to do whatever you want.

1. Under development

A side project is said to be under development when it fulfills at least one of the following:

1.1 It is unable to deliver its core reason to exist (it is not a MVP yet)

This rule is open to interpretation, but you can be honest with yourself here. For instance, if you are creating an image editing software, it should minimally be able to open an image file, allow its pixels to be edited, then be able to save the result as a new (or existing) image. That simple, a true minimum viable product.

1.2 It has not been publicly released

This rule might seem too much, but it is really required. It is the mental and public “acknowledgment seal” you need to move on.

The project must fulfill ALL of the following to be considered publicly released:

Users can download/install/use the project without your help. E.g. if it is compiled software, users should be able to download and run binaries.

Note: your project must have enough documentation to allow people to actually use it. Nothing fancy is required, a README file is enough and will do the trick.
Others can continue your work. E.g. if the project is an open source lib/software, it must have a README describing how to install (itself and dependencies), run and test things.

Note: no tacit knowledge about the project is allowed, e.g. something that only you know to make the project work, i.e. installing a specific a DLL file. Downloading the project source (and following its README) should be enough to put it up and allow further development.
It must be announced in a channel (or channels). E.g. tweet, blog post, project’s own website.

Note: the objective here is not to gather a lot of users for your project. The intent is to make the project visible in whatever channel(s) you have available.

Exception: if the project is a contribution to an open-source project, rules 1.1 and 1.2 are not required. In such case, the project is said to deliver its core reason to exist and is publicly released when a pull request has been issued and accepted (or declined).

2. On-going

A side project is said to be on-going when it is not under development (according to the previously mentioned rules 1.1 and 1.2) and it is being used by someone (including yourself).

Note: an on-going project might not be under development anymore, but it can still receive maintenance, i.e. bug fixes, or creative work, i.e. new features.

An on-going project only occupies one of the 5 working slots when it fulfills at least one of the following:

It received new features or bug fixes that were not released yet. E.g. new version of the project.

Note: releasing features/bug fixes for a on-going project is wrapping them up in a new release version, e.g. v1.5.0, and updating the project’s CHANGELOG.
It requires work to remain up and running for its users. E.g. add new content to a movie app, moderate submissions in a news portal, etc.

Exception: if the project is not related to software, then project version can be seen as making content publicly available. Similarly new content can be seen as new features or bug fixes. If you have unpublished content, you have an on-going project occupying a working slot.

3. Possible adaptations

Working habits, especially for side projects, are very dependent on personal inclination and energy. For me, 5 working slots is great, but it could be too little/much for you.

Similarly making on-going projects occupy 1 working slot each might be too much. An on-going project could occupy half a working slot, for instance. It’s up to you to find the right balance for everything.

cvui 2.5.0 is out!

2018-04-04T00:00:00+00:00

I am pleased to inform that version 2.5.0 of cvui is out! cvui is a simple UI lib built on top of OpenCV drawing primitives.

As usual this release contains contributions from several awesome people, so I would like to thank all contributors that have helped improve cvui. Thank you, you rock! New features for this release include support for multiple windows, a mouse API and the addition of cvui::imshow().

This post will give an overview of those cool new features. All GIFs in this post are from applications whose source code is available as examples in the cvui repository.

Support for multiple windows

In previous versions of cvui it was possible to render UI components to multiple windows. However components that respond to user interaction, e.g. buttons, would only work in one of those windows.

That was a significant limitation since multiple windows in graphical applications are quite common. cvui 2.5.0 no longer has such limitation:

Using the newly added function cvui::context(), developers can easily inform cvui of which window is being rendered/worked at any given time. cvui will internally track the state of each window and ensure that all UI interactions are handled properly, no matter the window.

Some existing functions were also updated and a few new ones were added to facilitate the work with multiple windows. For instance, you don’t need to create your own windows using cv::namedWindow() anymore (only if you wish so, of course). cvui can do that for you now:

const cv::String windows[] = {
    WINDOW1_NAME,
    WINDOW2_NAME,
    WINDOW3_NAME,
    WINDOW4_NAME
};
cvui::init(windows, 4);

All changes regarding windows are backward compatible, so existing projects should not face any problems. To learn more about this new feature, check out the multiple windows entry in the docs.

New mouse API

Mouse interaction is an important part of a graphical application. Particularly in computer vision applications, tasks quite often require quick iterations and selection of regions, for instance.

cvui has the philosophy of “one line of code produces one element on the screen”. This should remain true for a mouse API. The newly added mouse API provides lots of functionality without sacrificing simplicity. Everything related to the mouse is available via cvui::mouse(), which provide an easy way to query mouse information.

The function bool cvui::mouse(int query) allows you to query the mouse for events, e.g. cvui::mouse(cvui::DOWN). Available queries are:

cvui::DOWN: any mouse button was pressed. cvui::mouse() returns true for a single frame only.
cvui::UP: any mouse button was released. cvui::mouse() returns true for a single frame only.
cvui::CLICK: any mouse button was clicked (went down then up, no matter the amount of frames in between). cvui::mouse() returns true for a single frame only.
cvui::IS_DOWN: any mouse button is currently pressed. cvui::mouse() returns true for as long as the button is down/pressed.

The function cvui::mouse() returns a cv::Point which can be used to track the position of the mouse cursor. The combination of those two functions allow the creation of complex GUI with few (and clean) lines of code.

Below is a simple application demonstrating the new mouse API, whose complete source code has 57 lines in total (excluding comments).

The new mouse API seamlessly works with multiple windows:

All mouse functions also accept the name of a given window as a parameter, so you can get mouse info of any window in your application. Additionally it is possible to query information of any given button, e.g.

// check if left button of the mouse is down
// in the current window.
if (cvui::mouse(cvui::LEFT_BUTTON, cvui::IS_DOWN)) {
    // do something
}

// check if the middle button of the mouse is down
// in the window named WINDOW_NAME.
if (cvui::mouse(WINDOW_NAME, cvui::MIDDLE_BUTTON, cvui::IS_DOWN)) {
    // do something
}

Below is one application (source code available as an example) that uses the mouse API to dynamically create ROIs based on clicks of different mouse buttons.

To learn more about this new feature, check out the mouse API entry in the docs.

Better documentation

cvui documentation was completely overhauled, including the addition of several new code examples. Documentation pages have been significantly improved with code samples, figures and better explanations. All pages also have an Edit this page on Github button, so feel invited to improve the documentation as you see fit.

A tool is as good as its docs, so I hope this will make cvui even better.

Important changes

Finally I want to mention some changes that landed in this release. I tried my best to ensure backward compatibility, but unfortunately a small change is required to make cvui 2.5.0 work with existing projects. I am honestly sorry for any inconveniences this might cause.

From now on, one (and only one) of your C++ files must include cvui.h after a #define CVUI_IMPLEMENTATION, e.g.

#define CVUI_IMPLEMENTATION
#include "cvui.h"

int main() {

}

All other files should include cvui as usual:

#include "cvui.h"

int main() {

}

This change was required to keep cvui as flexible, simple and “sane” as possible. The function cvui::init() was also modified, but it should not affect existing addition of cvui::imshow() (equivalent of calling cvui::update() then cv::imshow(), as explained here).

Below is a list of changes according to the CHANGELOG.

Added

Support for multiple windows (help from Justin Muncaster, 4xle and Luca Del Tongo).
Mouse API (help from Pascal Thomet).
Compilation flag CVUI_IMPLEMENTATION (read more).
New parameter bool theCreateNamedWindow in init() (read more).
init(const cv::String[], size_t, int, bool) (read more).
watch(cv::String, bool) (read more).
cvui::imshow(), equivalent of calling cvui::update() then cv::imshow() (read more).
More examples.
Compilation flag CVUI_DISABLE_COMPILATION_NOTICES (read more).

Changed

cvui can now be included in multiple files (help from Luca Del Tongo; read more).
Requirement that one (and only one) of your C++ files must include cvui.h after a #define CVUI_IMPLEMENTATION (read more).
Documentation was significantly improved, e.g. code samples, figures, etc.

Fixed

sparkline() crashes with empty vector (#23).

Conclusion

cvui 2.5.0 is full of new features to help you improve your workflow and create awesome GUI applications. I hope this new release will make cvui even more useful.

As a final remark, the source code of all applications mentioned in this post is available in the examples folder of cvui repository. Inspect and use them as you please since everything is MIT licensed (as cvui itself).

You can pursue anything

2017-11-20T00:00:00+00:00

One of the first worries that hit me really hard when I became a professor was the influence I have on my students. Even if I just stand in front of my students, speechless and doing absolutely nothing, it will impact them somehow. They are there to learn not only the content listed in the syllabus but new experiences as well.

When I started, I was scared to say something that would not help them, that would push them towards the wrong direction. So I did what I experienced myself in the past. Something that helped me. I encourage my students to do anything. You know that famous saying?

You can do anything.

That’s what I did. There is no way to be more clear and straight to the point than that. You want to become an astronaut? You can do it! An athlete? Yep. The inventor of the next Facebook? Sure. Why not? I thought that was the right approach to impact my students. If they were to learn more than just the course material, it could well be something that inspired them to thrive and aim high.

One day I watched on YouTube a talk by Rami Ismail, a recognized game developer. The talk mentioned encouraging people to do anything they want. Again it was the famous “you can do it!” being spread in the wild. This time things were different though. Rami said something that resonated with me, something that made me realize how wrong my thoughts were. I can’t recall the exact words, but he commented how shallow pieces of advice like “follow your dreams” can be. Sure you should follow your dreams, but does the person giving such advice know the environment where the receiver lives in? He mentioned that some people just lack the required ground to engage in such endeavor. Following your dream might imply quitting your job, studying something that has a low financial return in the long run, and so on. It directly impacts your life, possibly changing it forever.

Being a Brazilian, I know exactly what that means. Lots of families in my home country need to fight to obtain the basics. My family was able to provide me with a good education, leisure opportunities, books, and trips. We were not rich, but for sure we were privileged. I never took that for granted, but I realized for the first time how “easier” it was for me to follow my dream compared to someone that did not share the same opportunities. That was the moment I thought everything I have been teaching to my students was wrong.

Advice as “follow your dream” is indeed shallow. It means nothing because it is mindless, blind and lacking any concrete steps. Combining it with “you can do anything” could be a recipe for disaster. It’s cliché to say, but everyone is fighting a battle you know nothing about. What if your advice is the wrong step in such battle?

The day I saw that talk changed my mind. I will never say “you can do anything” anymore because I know how much frustration it could produce. I’ve seen some of my students struggling to understand concepts of programming. It will only inflict pain on them if I repeatedly say “sure, you can do it!” when they struggle so much to do it. Maybe those students, in particular, have a tough time grasping programming concepts. That is pretty much my case when trying to understand how to play the guitar. For me, guitars are simply harder than programming. Can I learn how to play guitar? Sure, I can. Will it take me a lot of time and energy and the outcome will be very simplistic? Yes, it will. Period. Maybe my time will be better invested in something else, something that I also enjoy and I am more likely to thrive.

That’s the reason why I say “you can pursue anything” nowadays. It is way more grounded in reality because pursuing implies going after something. You need a target and a plan to do that. It is also implicit that you might not get there at all. Is it sad? Yes, but is better than chasing an unreachable ghost. I will tell you that you can pursue anything, but the path might be hard and energy-demanding.

I genuinely think that, as someone who can impact the lives of those in my class, I should measure my words. I need to join that individual battle, even if I know nothing about it. I can’t choose the path for that person in that battle, but I can help by giving an educated guess about how to pursue something. What are the challenges and probable steps ahead? And above all, don’t assume that we all have the same resources/passion/energy/time/conditions to pursue things.

You might not be able to do anything you want, but sure as hell you can pursue anything you want.

Experiences are what matters

2017-09-24T00:00:00+00:00

I started my studies in Computer Science at the Federal University of Santa Maria in 2003. I was very young and the only reason I had to study Computer Science was that I liked computers. I had no clue about what Computer Science would be, or what things I could do after graduation. I honestly had no expectations beyond improving my knowledge about computers.

That is for sure a naïve mindset to start a career, but today I see that you can’t get any more prepared than that when you are young and join the university. Since I was little everyone around me told me that the university was the ultimate goal, the final frontier someone could breach into. I did my best in school and eventually I complied with this idea when I entered the university education.

I remember the feeling of being amazed by the whole thing. My first thought was:

You have to enroll in courses to learn about different things! If you don’t do it, nobody will do it for you. How cool is that?

I thought it was so different from regular school, where you learn lots of pre-defined things in sequence, one day after another. University was not different than that at all, but it sure felt different. I had the feeling of freedom, of picking the things I wanted to learn. Even though I disliked several of the topics that I was learning (I am more of a practical guy instead of theoretical), everything that was being presented somehow contributed to my knowledge.

My young soul was full of dreams. The more I discovered, the more I wanted to learn. Officially I only learned the C programming language during programming courses, but curiosity, good colleagues and studying groups provided me with Java, Actionscript, C++ and PHP. Back in those days, I thought that I needed to learn all programming languages to be successful. It is incredible how I saw the world in an entirely different way during that time.

The years have passed (precisely 14 of them) and I see the same world so differently that I could as well say I am no longer the same person. The classes I attended, all the content I’ve learned faded and converged into a single thing I remember today: the person behind the teaching process. Sure it was important to learn about math, system architectures, software engineering, but the only value that remained was the experience I had. I remember the stories some professors told me, I remember their passion, their clever way of overcoming problems. That was the most important thing I have learned.

Back in 2003 there was no computer vision able to detect and identify objects (not at my university at least), nobody was talking about deep learning and Javascript was the black sheep of the Internet. In the helm of technology, things change at a neck-breaking speed, so the landscape is very different today than it was 14 years ago. The experiences I had, however, still remain and they are the elements that define me. They made me the professional I am today.

That was one of the main reasons why I decided to do my PhD abroad. I wanted to learn from different lenses, from different people. I am so thankful for having the opportunity to study in Sweden. Just like the experiences I had in 2003 changed my life, the years I am living now will define me even more. If I could give a piece of advice to my past self, I would say:

Understand the challenges in front of you as a school to teach you how to learn. Some things you are learning now are important, some are not. Learn how to learn, and learn from the experiences presented to you.

That is definitely how I live and learn now. You don’t have to go to the university or get a PhD to learn about many things. Everyone has a life of experiences you can learn from, no matter their social class or level of instruction.

Learning from your own experiences and the experiences of others is what matters, the rest you read from a piece of paper.

cvui 2.0.0 is out!

2017-08-06T00:00:00+00:00

I am pleased to inform that version 2.0.0 of cvui is out! cvui is a simple UI lib built on top of OpenCV drawing primitives. This post is a bit overdue since the release happened in May, but better late than never.

Version 2.0.0 is packed with new features, however the API remains the same, so it is quite easy to upgrade. The inner parts of cvui have been completely overhauled, allowing better support for old versions of OpenCV, e.g. 2.x.

Here is a complete list of additions and changes (including CI builds):

Added

image()
iarea()
trackbar() component (thanks to Pascal Thomet).
Support for OpenCV 2.x (thanks to Pascal Thomet).
Basic cmake support for examples (thanks to Pascal Thomet).
Multiplatform improvements (thanks to ebachard).
More examples.
Better documentation.

Changed

cvui is now a header-only lib.
button() component can now use images.
Labels in the button() component can have keyboard shortcuts with &, e.g. &Quit (thanks to Pascal Thomet).
Fixes to README file (thanks to Mateo Hrastnik).

One of the things I am most happy about this release is that cvui is now a header-only lib. I am a huge fan of such approaches since they are easy to integrate and use in a project. Additionally there is a new website full of documentation and examples related to cvui.

Following the release of version 2.0.0, I made a guest post at learnopencv.com about cvui. It highlights the true nature of the project, which is allowing developers to do a lot with very few lines of code. For example, the following application has 37 lines of C++ code (including blank lines as well):

I also want to thank all contributors that have helped improve cvui! If you have not tried cvui yourself, take it for a ride.

Jabref - reference manager for latex and bibtex

2017-04-07T00:00:00+00:00

Managing references is a common and daily task of any academic. It consists of keeping track of papers you have read and how to cite them in the future. If you are involved in a little endeavor with a few papers to monitor, you are good to go with a folder where you store the PDF files and pull the citations from there.

I am a Latex user, so I organize all my references using Bibtex. It’s an easy to use format that works most of the time flawlessly. A Bibtex entry usually looks like this:

@inproceedings{bevilacqua2016variations,
  title={Variations of Facial Actions While Playing Games with Inducing Boredom and Stress},
  author={Bevilacqua, Fernando and Backlund, Per and Engstrom, Henrik},
  booktitle={Games and Virtual Worlds for Serious Applications (VS-Games), 2016 8th International Conference on},
  pages={1--8},
  year={2016},
  organization={IEEE}
}

At the beginning of my PhD, I used a Bibtex file (e.g. references.bib) as my reference manager. Every time I read a paper, I added a new entry to that file and dropped the PDF into a folder. Simple and straightforward. Meanwhile, I kept on hearing several suggestions regarding the use of a (bibliography) reference manager. I soon realized why a reference manager is not only useful but definitely required.

As you deepen the research, the number of papers you have to deal with grows significantly. The number of files per se is not a problem, but remembering who wrote that piece you want to cite is the tricky part. Say you remember a few keywords, but you don’t remember the author (or the other way around). That’s when a reference manager saves the day. By using one, you can quickly search papers by author, year, keywords, conferences, anything you can index on.

JabRef: open-source reference manager

When I decided that a reference manager was necessary, a quick search returned names like Mendeley, one of the most mentioned suggestions regarding reference management. I believe that is because it easily integrates with Microsoft Word. Endnote was another popular (and expensive) suggestion. Being an open-source fanatic, I googled for OSS alternatives and found JabRef. It is quite a piece of software, kudos to the development team!

JabRef not only helps you manage your references, but it also helps you obtain information about them. Usually, my workflow involves searching for a paper on Google Scholar and getting its bibtext entry from there. After I add the entry to JabRef and use its excellent features set to automatically look up the DOI and the PDF of the paper for me. And just like magic, my initial bibtex entry is updated with very accurate info and ready to be used. Additionally, JabRef uses a Bibtex file as a database, so there are no intermediary files or similars. JabRef works as a nice GUI to edit (and improve) bibtex files. Straight to the nail for Latex users.

If you are writing anything in the academia or doing research, start using a (bibliography) reference manager as soon as you can. JabRef is free, open-source and works great with Latex.

Scifibot - Devlog 2

2017-01-20T00:00:00+00:00

This is the second update on Scifibot, my companion app for sci-fi fans. Things are finally starting to take shape, which is great and bad at the same time. It’s great because the app is coming together and I can actually see it working. The bad part is that I reached the 90% development mark, which means I have only 10% of work to go. Right?

If you have experience shipping any software that targets real users, you know the last 10% of the development actually represents 90% of the project. That’s the amazing development math, but it is true if you want to deliver a product with decent UX instead of a clunky pile of non-functional buttons. My last tasks regarding Scifibot have been almost exclusively focused on UX, like tweaking menus, adjusting buttons, creating visual feedbacks for actions, etc. It’s a boring task to me, but it needs to be done.

I also added some love to the title screen (the one showing the details of a movie/series). It’s now possible to see real ratings from IMDb, Metacritic and Rotten Tomatoes. I also decided to leave the reviewing of titles out of the app for now, because it will consume a significant amount of time to implement. I want this app out quickly, so it’s time to start dealing with feature creep.

Under the hood I worked on the synchronization code, which is responsible for updating the app’s database with new titles informed by the REST API. I designed both the API the and sync system to consume as little network resources as possible. The app will never ask the server about the full database, it will ask for modifications since a timestamp instead. It should prevent the download of already acquired info, cutting data transfer. I also implemented an “offline sync” procedure, which is used in case the app is updated via Google Play. Internally any new version of the app will be seen as new data to be sync’d, so I can actually update the catalog of titles using Google Play updates, if necessary.

Things got a bit complex after the sync system was in place, so I needed a way to trigger sync actions manually. I spent a few hours and created a settings screen. At the moment it has the bare minimum required for the app to run, like an option to enable/disable remote sync, allow device notifications, etc. I don’t plan to add much more options to that screen, but it is there (and already working) if needed.

Last but not least, I worked on the notification system. It will be responsible for informing the user about new content, especially info regarding titles the user is tracking/following. The gif on the side has a demonstration of the notification system showing two new titles that were added to the catalog recently.

At the moment my focus has been on fixing bugs. There is a very nasty one regarding dynamic screens and navigation. I thought I was using Framework7 in the wrong way, but it seems it is not my fault. It looks more and more like a bug on their side, but I will work around it. After this bug is fixed, I think the app reaches alpha status and I can start packaging and deploying it on real mobile devices. I’m looking forward to doing it!

Scifibot - Devlog 1

2016-12-21T00:00:00+00:00

I love scifi movies and series. There are plently of good (and not so good) titles out there to be seen, but it is really hard to find them or keep track of interesting things. If you are like me, you probably had spent a significant amount of your time 1) finding things and 2) making notes or equivalents to remember what to watch.

I would like to see a list of every scifi movie or series available with a clear indication if I had or not watched it yet. I want to see a cool movie/series and add it to a list I can come back to later. More importantly, I want to be informed about the titles I am interested on, e.g. receive a notification when an upcoming movie hits the theaters.

Filled with frustration of my current workflow to find/track things and inspired by the bright future described above, I decided to work on a mobile app. Its codenamed Scifibot. I have managed to work on it during the weekends and sometimes during the weeks at night.

This post is a dev log regarding my progress so far. I wanted to quickly finish this project, so I decided to stick with web technologies (HTML5/CSS/JS) on top of a runtime (e.g. Phonegap or similar). After spending some time reading about and testing a few mobile frameworks, I decided to go with Framework7. I had never heard of that before, but it is a full featured HTML framework for building iOS & Android apps. It is simple, efficient, elegant and easy to grasp.

After my first coding session (about 2 hours), I was able to put together a very simple app fully implemented on top of Google Material Design, which is a must for Android. That was impressive. I had used jQuery mobile in the past, but my progression at the time was not that good.

My development focus has been on creating the basic structure of the app, creating the screens and the flow among them. Here is an screenshot of the current state:

I had a few quirks regarding some aspects, such as the navigation bar and its buttons. It is probably because I am doing something wrong, but I will deal with that later. The plan is to move fast and reach a MVP, then iterate from that. As any good side project, feature creep has already took over, but I moved several of the non-essential features to the “Cool to have in the future” pile. The project should be safe for now :D

I want a functional app, so it should be fast and self-contained. As a consequence, no login will be required and no internet connection too. However, if the user wants to backup any saved things or make reviews, for instance, authentication will be required.

Here is a gif showing a bit of the app (it is alpha state and totally incomplete):

If you like scifi, stay tuned for my progress. This app will be available on Google Play in the near future, specially because I am tired of keeping track of movies/series to watch in an archaic way.

Writing software to write software

2016-11-11T00:00:00+00:00

Since I started my PhD in September, 2015, I have been writing a lot of code. My research project contains its fair amount of theory, but it is significantly practical and applied science, so I need to write software to test things out.

A percentage of my coding was indeed targeted at creating original software that could do something related to my research. Another significant part, however, was about automation:

Source: xkcd: Automation

In my case, doing applied science means I need to iterate, test and evaluate a lot of things on a daily basis. I could do the analysis by hand, or by copying-and-pasting numbers back and forth in Excel. In the short term that works perfectly well, but things start to grow and become more and more error prone in the long run.

In February 2016 I conducted an experiment involving games, facial expressions and heart rate measurements. Each participant spent, on average, 25 minutes in a gaming session, which involved playing 3 different games (two coded from scratch by myself), resting and answering questionnaires. I could be there in the room, with a notebook frantically taking notes of things. Then I would need to transcribe all that information into a spreadsheet to perform further analysis. Again the chances of misplacing numbers here and there is very real (and dangerous), so I wrote a software to run the whole experiment for me.

During the development time, I even spent a few additional precious hours to create a very simple web interface, accessible from my mobile, to monitor the experiment. That was awesome! Even though I was not in the experiment room, I could just light up my phone and see what was happening. Was the participant playing game #2? Or maybe resting? I could enter the room at the precise moment the experiment was over.

Later on I needed to analyze all the data I collected. Solution? I wrote another piece of software to visualize the data (since everything was custom recorded):

A few months after the experiment, I started a paper about it. I needed several different chunks of data and reports, so I distilled several command line utilities (e.g. analyze and hr2db) that helped me obtain what I wanted. As a side note and honest advice, don’t write crappy and/or undocumented software just because you are the sole user (at the moment). Doing a PhD often involves switching contexts pretty frequently, so at times I only re-used (or coded again) a utility 2 months after its creation. Despite being the author of the tool, it is fair to say I remembered nothing about it after 2 months doing other things. The tool might as well be considered to be written by someone else.

That’s the reason why I tried my best to make the tools at least UX-acceptable with a minimum amount of documentation:

Usage:
 php analyze.php [<subjectId>|<firstId>:<lastId>] [options]

Options:
 --report         Prints the processing as a report.

 --csv <file>     Saves the processing as a CSV file defined
                  by <file>.

 --export <file>  Exports all HR entries as a file defined
                  by <file>.

A few months ago, I had to analyze a database of 530 videos, all containing BDF files unsupported by my software. I needed only the HR from those BDF files. I found several different programs that could convert the files to me, but they required manual interaction with a GUI. Solution? I wrote BDFextractor to extract the HR from BDF files using the command line. Now I could run (another) little software on the database and export the HR from all those 530 files. Victory!

I have been writing lots of R code lately, to perform statistical analysis and plot some charts. I can confidently say I wrote more multi-use support software in the past year than I thought I would.

Writing that much software might be seen as a waste of time, after all there are plenty of solutions out there for virtually everything. Every move demands time, though, be it learning (or developing) a new tool. Time is an incredibly precious resource, so I always choose the option that better accounts for that. Every time I have to write a small tool, I remember the advice from an old saying about chopping off of a huge tree: if you have to do it, you better have the right tools and be sure they are as sharp as they could be. That’s a fact.

cvui 1.1.0 is out!

2016-08-19T00:00:00+00:00

I am pleased to inform that version 1.1.0 of cvui is out! cvui is a simple UI lib built on top of OpenCV drawing primitives. Here is an image to show the new features:

This release is backward compatible, so users of the lib should be able to upgrade by just dropping the new files into their projects. There ara few bug fixes as well as some pretty cool new features.

One of the most annoying tasks when building UI is to calculate where each component should be placed on the screen. Version 1.1.0 brings a set of methods that abstract the process of positioning components, so you don’t have to think about assigning a X and Y coordinate. Instead you just add components and cvui will place them as you go.

An example is the beginRow() function to start a group of elements. After beginRow() has been called, all subsequent component calls don’t have to specify the frame where the component should be rendered nor its position. The position of the component will be automatically calculated by cvui based on the components within the group.

All components are placed side by side, from left to right. E.g.

beginRow(frame, x, y, width, height);

text("test");
button("btn");

endRow();

Rows and columns can be nested, so you can create columns/rows within columns/rows as much as you want:

beginRow(frame, x, y, width, height);

text("test");
button("btn");

beginColumn();
text("column1");
text("column2");
endColumn();

endRow();

I am pretty happy with the new API and the possibilities it brings, specially because it means less code to achieve more things. That’s always a thing to celebrate =)

cvui - A very simple UI lib for OpenCV

2016-06-17T00:00:00+00:00

I have been working a lot with OpenCV and C++ lately. After spending a great amount of time waiting for things to compile (so I could see my changes), I decided to improve my workflow. I decided to make changes in runtime, so I could tweak things without the need to recompile the whole project.

I immediately faced a problem: how to quickly and easily create GUI with OpenCV. The OpenCV lib has complete support for Qt (which is great for UI creation), but you need to compile OpenCV with such Qt support. If you don’t like that (or you have OpenCV compiled without Qt), you can enable OpenGL and use any of the awesome GUI out there, e.g. imgui. If you decide for that, you add the OpenGL dependency to your (probably already complex) project.

I didn’t have Qt available and I didn’t want to use OpenGL, so I distilled cvui. cvui is a (very) simple UI lib built on top of OpenCV drawing primitives. All the rendering is made using OpenCV, by calling cv::rectangle(), for instance. Here is a picture of it working:

The API is heavily inspired by imgui. The calls are all C-like, so no classes, objects nor OOP. I have nothing against that, I just wanted an extremely simple way of creating UI for my application (one line written, one thing on the screen).

At the moment, the API includes a small set of components: button, checkbox, window and counter. I will probably add more components in the near future. For more information, visit the cvui repository on Github. The code is MIT licensed.

Goodbye Wordpress, hello Github Pages!

2016-03-28T00:00:00+00:00

It took a lot more than I wanted it to take, but I finally concluded the move from Wordpress to Github Pages! Finally my personal website (this one you are reading) runs in a static fashion, without PHP, databases and all that useful-but-not-for-my-personal-website stuff.

I enjoyed Wordpress from the very beginning, it has a nice set of features and helps you write and manage content. During the last year or so, however, it was standing in my way. The template I was using was already showing signs of aging, some things were breaking and, last but not least, I had to pay constant attention to security patches/updates. Not anymore! Now I can use my daily code editor to write content using Markdown and publish it to the magic clouds of Github with a git push command.

I hope the move will encourage me to blog more often, which is something I have being trying to do lately. Time will tell if that worked or not :)

My 2013 in review

2013-12-30T09:56:18+00:00

Another years has gone by. I wrote my new year’s resolutions for 2013 almost a year ago, but it still feels like yesterday. The last days of 2013 seem the perfect time to review the year and check if I collected accomplishments or lame excuses.

Without further ado, down to the goals:

Improve my skills as an indie game developer. I already joined OneGameAMonth and will try to release 12 games in 2013. A pharaonic task, but the fun is proportional. It is not about working until faint, but learning how to avoid code bloat and feature creep (two of my most significant problems as a developer).

Depending on the point of view, this was completely or partially accomplished. I did not release 12 games in 2013, I did 6 instead. 1GAM was amazing and I’ve learned a lot from it. The “12 games” thing was just a guide, not a goal per se.

As I explained here, my gamedev year was awesome. I can say I improved as an indie game developer, a LOT.

Exercise! I stopped running with my friends (in 2011, I ran a 10km marathon, that felt great!). I want to start jogging at least. I also want to get back on track on my push-ups training. I will buy a dumbbell too.

Partially accomplished. I got on track on my push-ups and the jogging, but I didn’t follow a strict and regular routine.

I trained for a marathon, signed up for it and was ready to run. However I’m too dump to pay attention to the payment due date, so my registration was invalidated Damn! It was a fun and short 5km marathon that I will have to postpone to 2014.

I didn’t buy the dumbbell.

Regularly write tutorials about game development at As3GameGears. Since I started the blog, I just post about tools. It’s time to improve the content and write about game related stuff.

Again, depending on the point of view, I completely or partially accomplished this one. I did wrote several gamedev tutorials, but for the Game Development section of the Tuts+ network, not As3GameGears.

On the other hand, I kick started a new series named game dissection. It’s not a tutorial, but it’s a start.

Write a book about game development.

Not accomplished. Judging by my work in March and April, I thought I would accomplish this one. I wrote two chapters, then I totally dropped the work.

My university classes consumed a significant amount of time, so I was not able to write chapters. I was planning to write and use the texts in my gamedev classes, but that didn’t happen either. Too bad.

Contribute to an open source project.

Accomplished! I worked on Flixel Community, fixing bugs and planning new features. By the end of November we released version 2.56, the very first Flixel release under the community label.

We attracted more developers to the project, that was amazing! I will continue my efforts to make Flixel Community a great game engine.

Found a Jr tech company at UFFS.

Not quite there yet. I mentored students regarding the tech company, which was founded and named FronteiraTec. In the founding process, however, we skipped all legal and governamental steps, so the company exists, but in a “virtual”.

In that situation, the company is not able to sign any contract or sell anything, but it didn’t prevent the students from planning and working. They worked on several projects, covering subjects as games, mobile apps and hardware. They even made an arcade machine.

The only missing piece of this puzzle is the legal papers and the official registration in the government records.

Research. It’s been two years since I stopped working on my master’s dissertation. I want to start working on it again, researching and publishing papers.

Not accomplished. I didn’t have the time (nor the will) to keep this up. I co-authored a paper about procedural generation of canyons, though. The paper is in the works, but it will be published in 2014.

Find inner patience. Sometimes I get really upset by small things and it is not helping. I will try to keep myself calm and constant during 2013. It will make me a better husband, professor and person.

I don’t know how to classify this one. I made some great improvements, but I didn’t reach the point where I wanted to be.

Finding inner patience is harder than I thought. It requires a lot of energy to take a deep breath and ignore the things that upset you. The jogging helped keep things cool, so I think I’m on track for this goal in 2014.

Release at least one side project. I have lots of ideas, but I never manage to work on it and release something.

Not accomplished. I joined my friends on a project, we had some meetings, but we were not able to launch anything. I had some ideas too, but I was short on time to make them come true.

Ok, that was the review!

Looking back and checking all those accomplishments, I can say 2013 was an outstanding year! Goals keep me motivated, even if I’m not able to accomplish them all. I managed to accomplish much more than I expected, which was great!

A new year is just around the corner. It’s time to write some new goals again 😀

Gamedev book – days 1 and 2

2013-03-22T17:37:59+00:00

It’s been three weeks since I started working on this book. During Friday the 15th I finished the summary. I came up with 19 chapters! That’s more than I previously thought, but since it’s a draft, I can cut some chapters along the way.

Today I finally started writing something. Damn, it was hard! It’s been almost 3 years since I wrote something big (my master thesis) , so I had to brush all that dust. The key secret for every endeavor is persistence, so it took me some time to get things working again. At the end of the day I was really proud of my result. It was a small piece of text, but it served the purpose of warming things up.

Analyzing the current scene I will merge some chapters and change the main subject of others. However that’s a task for the future and for my next Friday.

Gamedev book – day 0

2013-03-08T19:00:39+00:00

I am thrilled to say that today I’ve started writing my book about game development! Every great (and huge) journey starts with a single step, which probably is the hardest one. This book is one of my new year’s resolutions for 2013.

I’ve been planning to start this book since the beginning of the year, but university work (and some side projects, such as 1GAM) swamped me with tasks. I knew there was no easy way to start this book, so I reserved 20% of my week to work exclusively on it. My workmate Denio and I made a pact to progress a personal side-project during a specific day of the week. We chose Friday for that and named it “Insane Friday” (sounds much better in Portuguese).

Sharing a common day to work on our projects is great because it helps us focus on the job, even though we are working on completely different things. No matter how much university work we need to overcome during Friday, we must progress with our projects, that’s the rule. I know 20% (a single day of the week) is not the perfect amount of time to finish a book, but I need to start with a healthy pace. The idea is to (hopefully) increase that amount over time, but smoothly.

During my first day of work, I did the obvious: planned the content. I brainstormed all the subjects I want to cover, then I wrote them down on a draft summary. Our first Insane Friday just lasted for a couple of hours, so I was not able to make my draft become a real summary, but that’s already a start.

I am looking forward to working on my book again. I will blog every week about my progress, so I can keep track of the time and measure how many centuries it will take me to finish this book :D.

My new year’s resolutions for 2013

2013-01-03T08:20:11+00:00

Last year was amazing! It was my second year working as a professor, something really different from the life I used to have as a game developer at Decadium. I experimented much more and the overall was pretty good. I am happy with the results

I got so many ideas during last year that I end up surrounded by a vortex of them. Lots of those ideas came to reality, but a huge amount is still out there, waiting to be implemented. This year I will try to stick with the list below, my year’s resolutions for 2013:

Improve my skills as an indie game developer. I already joined OneGameAMonth and will try to release 12 games in 2013. A pharaonic task, but the fun is proportional. It is not about working until faint, but learning how to avoid code bloat and feature creep (two of my most significant problems as a developer).
Exercise! I stopped running with my friends (in 2011, I ran a 10km marathon, that felt great!). I want to start jogging at least. I also want to get back on track on my push-ups training. I will buy a dumbbell too.
Regularly write tutorials about game development at As3GameGears. Since I started the blog, I just post about tools. It’s time to improve the content and write about game related stuff.
Write a book about game development. That one is the toughest. I wrote a couple of tutorials last year, but they were small compared to a whole book. This item was in my year’s resolutions for 2012 as well, but I didn’t touch it during the year. What a shame! Let’s hope this year things will be different.
Contribute to an open source project. This one is already happening since I joined Flixel Community team. Flixel is a great game engine for Flash and I want to work hard to make it even better.
Found a Jr tech company at UFFS. I’ve been working on that during the last months and it is almost done. It will improve the students perception about the world out there. My idea is to establish some sort of incubator-venture-capital-startup-booster company. I know, I know, but it works in my head 😀
Research. It’s been two years since I stopped working on my master’s dissertation. I want to start working on it again, researching and publishing papers.
Find inner patience. Sometimes I get really upset by small things and it is not helping. I will try to keep myself calm and constant during 2013. It will make me a better husband, professor and person.
Release at least one side project. I have lots of ideas, but I never manage to work on it and release something.

All right! That’s quite a list. If I accomplish half of it, it will be a huge step per se. I’ve noticed I’m some sort of TODO list addicted. No matter if I accomplish the items, as long as I have a ton of them. Pretty creepy. I’ll work on improving that too.

It’s time to keep the focus and work hard. The problem with a big list like that is the first step: where should I start?

Open-source projects of one man army

2012-11-24T17:37:21+00:00

I am not a new “consumer” of open-source software (OSS). In fact several tools I work in a daily basis are open-source. The OSS idea of freedom to create, share and help others (most of the time for free) always fascinated me.

I’ve been planning to jump into that open-source world for a while. And for “jump into” I mean start contributing code/ideas/energy instead of just watching things happen. I was certain I would not write the shiniest nor the best code in the world, but heck, I had to start! After a while, I started looking at the projects I use every day to find something to start contributing to. After some time, I must say I saw something pretty strange, but rather common in the community: projects with a single developer. It is a project founded, coded and maintained by a single person. That’s honorable and bad at the same time.

If you have a single point of failure, any fluctuation will generate a huge impact. If for some reason the author can’t work on that project (for a short period or for months), there is nothing you can do about it. You can contribute to that project doing things that do not involve the author (such as reporting bugs, answering questions at the forums), but you can’t do anything beyond.

As a consequence the project may experience an inactivity time. Even if you can fix a bug, you can send a patch (or a pull request, for Github lovers) but it will land only when (and if) the author comes back. In the worst case scenario the project will slowly fade away, unable to catch up with another developer (or team). Here comes another huge misunderstanding of the idea behind OSS that I noticed in the users of some projects: the author must continue the work. That’s nonsense! The developers owe you nothing!

When you start an open-source project, it can be for a variety of reasons. Maybe the author just thought it could be a cool idea, he was trying something new or he got bored. It doesn’t matter the reason, but I am pretty sure when the projected started, the author did not sign any contract using his own blood to seal a connection that guaranties he will work on that project for the rest of his life. The same way the project started, it can end, because the author got a new job, had a baby or got tired. That happens.

Complaining is not an option. We can do better than that! If the project is open-source (and the license allows it), anyone in the world can fork it and continue the work. I know that a forked project may not be as strong as the original, but it’s alive at least_. _If you can gather more developers, the fork may end up being as strong and popular as the original project.

I might be new to all that OSS development, but I thought everyone already knew that.

Using ChromiumOS in a daily basis

2012-06-10T23:15:44+00:00

The very first time I heard about ChromeOS I thought it was an amazing idea. I always hated the painful process of keeping a computer running smoothly, which consists of formatting, installing OS/apps, update everything, repeat it all. When Google released their Chromebooks, I joined the waiting list, but they were not available here in Brazil. Damn it!

It did not stop me from trying ChromeOS. After some time, I searched the web and found ChromiumOS builds by Hexxeh. I first created a bootable USB stick carrying the ChromiumOS and used it a couple times. It was cool, so I decided to go hardcore and installed ChromiumOS on my notebook (Lenovo ThinkPad T400). Those are my first impressions.

Is it fast?

No and yes. Deeply inside I was expecting an extremely fast boot time (the famous 8 seconds), but I got a 23s boot. I know I don’t have an official Chromebook, so I was expecting that “slow” boot time. The resume time, however, is dead-fast. I guess it takes about 2 or 3 seconds to be ready to use after I open the notebook lid. Great!

Excluding the boot and resume time, everything feels fast. The windows, the apps, the UI. The OS interface is easy to understand and is simple, no complex options.

Can you still do everything you used to using another OS?

It depends. All tasks that are not related to game/app development I am able to do, such as create/view docs, read e-mails, blog, etc. I could even plug a data-show into the notebook and share the screen to use in my classes. I did not create anything unusual yet such as a banner or an image using any image editor in the cloud, but so far, so good with the rest.

About my development tasks, I cannot perform any of them using ChromiumOS. Google already knew that was a problem for several developers out there, so they created Chrome Remote Desktop, an extension that allows me to remotely access my other computers. I must say that it is fast, really fast! I’ve been using LogMeIn or Windows Remote Desktop for that, the latter being the fastest. Chrome Remote Desktop is so fast that I feel like using the remote computer locally. It will fill the gap I need to use ChromiumOS to develop, however I still need another computer.

Is it buggy?

Sure! I assume ChromeOS is able to use the Chromebook hardware perfectly, but it is not able to do the same with my Lenovo. I was already expecting that. My trackpad works relatively well and all notebook shortcut buttons (such as the volume ones) work as well. However I am not able to use the trackpad to perform all OS gestures such as tap with two finders then drag them away from each other.

Something I was not expecting was the network problems. Frequently ChromiumOS is unable to load any website, reporting there was a DNS problem. My network is just fine, because all other computers are using the Internet normally (using Chrome, by the way). To fix that I must constantly disable and enable the network, so everything starts to work again. Sometimes after the network reset ChromiumOS keeps telling me my device is offline, even when it is not.

Final thoughts

I am happy with the experience so far. It is a new concept and I think it is the future. I’ve been trying to integrate ChromiumOS into my life one step at a time, starting with home activities. I plan to use it on my work too, but I need to set everything up first.

Stay tuned for more reports!

I told my 2nd year CS students to create a programming language [RESULTS]

2012-05-14T18:21:05+00:00

A few weeks ago I told my 2nd year CS students to create a programming language and here are the results of such assignment. I am sorry for the long post, but I used any good information I collected.

I have 24 students attending my classes. The assignment was supposed to be performed by pairs within 3 weeks, but I had two students that decided to go alone, so there were only 11 pairs of students. I was expecting a high number of accomplishments, but it was better than I thought. In the end, just one pair of students didn’t show up for the presentation day, all other students were there with a working interpreter.

A little lie

According to the assignment description, the interpreter should be able to handle if’s and loops in order to get a good grade. I would test that asking them to implement two programs: #1 calculate the average of two numbers and #2 check prime numbers. If the interpreter was able to run program #1, they would be graded with at least 4.0 (up to 10.0). If the interpreter was able to run program #2, they would be graded from 8.0 to 10.0.

I told them this little lie to keep everybody focused and avoid extremely simple interpreters (e.g. able to handle variable assignments and expressions only). I evaluated the interpreters using the students hard work and the evolution they had on subjects they learned during the classes.

The languages

The very first thing I noticed was that they focused all their manpower on trying to create something able to interpret program #2. As a consequence, 12 of 14 interpreters were able to handle if’s and loops, but not nested ifs/loops. You could use several ifs and loops as long as they were not nested. However all those 12 interpreters were able to handle loops containing several ifs, as long as they were not nested among each other. One pair of students did not implement if’s/loops.

I assume this “non-nested thing” happened because they were thinking about checking prime numbers using a loop containing some if’s. Some samples I found (translated to C for the sake or understanding):

if(exp) {
  // only variable assignments allowed here.
}
while(exp) {
  if(exp) {
     // only variable assignments allowed here.
  }
  if(exp) {
     // only variable assignments allowed here.
  }
  // the following is not allowed here:
  while() {
  }
}

Several students told me at the end of the presentation that they had ideas to allow nested if’s/loops, but they had no time left to implement it. They also said there were too focused on small things (e.g. variables) and forgot to check the big picture. One pair of students used an “assembly” like approach and implemented the goto, so they their code allowed nested if’s/loops.

About 5 interpreters used an “op-code” like grammar, so the programmer must start every statement with an “instruction op-code”, e.g. assign a = 2 + b. I think they did that because they thought it would be easier to analyze every line, but in the end they noticed it was not that useful.

Just 3 interpreters were able to create variables on the fly, such as PHP does, where $var = 2 declares $var if it is not already declared, or it assigns 2 if $var already exists. All other interpreters force the programmer to previously declare variables. I think it happened because they wrote just C code until now (they will meet PHP next semester).

Several interpreters were very sensitive about the spaces among tokens. As a consequence the programmer must use the exact number of spaces among tokens, otherwise it would not work. Just a few interpreters could read the code one char at a time, which allowed them to ignore extra spaces. All other interpreters used some sort of split method based on spaces/tabs/separators.

Five interprets had input commands, pretty much like input var;. The assignment description had no requirements about that, so it was cool to see them implementing something beyond what I asked for.

I also saw one interpreters able to handle complex math expressions (more than two elements/operators), but analyzing it from left to right with no operator precedence; I also saw typed vars (including int, float and string!), predefined variable names (you could use “a” to “z”, and nothing else :)), output with value substitution (e.g var = @var produces var = 2).

Students feedback

The week after the students concluded the assignment, I issued a poll to check their opinion about all they had to go through. Those were the results:

How difficult was it to implement this assignment?

Pretty easy			0%
Easy			5%
Regular			11%
Hard			42%
Pretty hard			42%

From 0 to 5, being 0 just a little and 5 very much, how much do you think this assignment helped you to understand the concepts we studied?

0 –	Just a little	0%
1		11%
2		5%
3		21%
4		16%
5 –	Very much	47%

How much fun did you have doing this assignment?

It was death boring, don’t ever do that again!	16%
It was fun!	68%
It was damn cool!	16%

Would you recommend me to repeat this assignment in the future with other students?

Yes			89%
No			11%

Conclusion

It was outstanding! My very first goal with the interpreter was to make them understand about objects, classes, methods and their relation. I could have asked them to implement a simple calculator to enforce those concepts, but as I told before, it was too boring.

I broke the line and pushed them really hard and they were able to handle it. I think nobody got depressed or something like that. I am very proud of them and looking forward to publish the next big assignment: a Guitar Hero like game.

UPDATE: discuss it on Hacker News.

I told my 2nd year CS students to create a programming language

2012-04-13T19:19:43+00:00

I teach object-oriented programming using Java to 3rd semester Computer Science students at Federal University of Fronteira Sul. During their first years, the students attend to algorithms and data structures classes, all using C. I teach algorithms too.

I like to teach using assignments. During the last two semesters, my OOP/Java classes were followed by small assignments, every two weeks. Those assignments were strictly related to some topic being discussed during the classes. I was afraid to push my students too hard, so the tasks were easy (in my opinion) to understand and complete. I already told them to implement a tic-tac-toe game, a simple Android app (at the end of semester), a simplified bank management app, among others. However they are all boring tasks.

This semester I decided to take another approach. I wanted to push my students to the limits. After two months of classes, they were already familiar (or I thought so =) with objects, classes, strings and arrays. So I fired the first assignment: implement an interpreter for a programming language each pair of students must design. The language must have the following “feature” set:

Declaration of variables
Assign values to variables
Math expressions with at least two members (e.g. 2 + 2)
ifs
loops

Boom! When I told them about the assignment, they were a little bit shocked. They will get in touch with subjects as compilers only at the beginning of the 4th year, so I told them some basic tips about interpreting a language, such as analyzing tokens and using a dictionary to store and manage variables.

After they digested the information, they started designing their languages. They looked like they were having fun doing that. During the last two weeks, they have been working on that assignment. Lots of questions, lots of ideas and approaches. So far, so good.

I don’t really expect them to create a production ready language interpreter. My goal with that task was to enhance their understanding about objects, classes, methods, instantiation, etc. They will empirically learn about a programming language structure. It’s been great so far.

Next week they will present their interpreters. In order to make things even cooler, each pair of students must implement two programs using somebody else’s language. I know this may not be the best approach for teaching OOP/Java, but it’s way better than boring simple tasks.

UPDATE: check the Hacker News thread.

Nokaloompas

2011-09-30T20:43:24+00:00

My friends at Decadium just released a new game called Nokaloompas. It’s a funny puzzle game that has the inverse gameplay of Cut the Rope, meaning you have to add ropes in order to achieve the level goal (carry bombs around)

Play for free at Kongregate.

AS3 GameGears

2010-05-06T23:42:04+00:00

Flash game developers – meet my new project: AS3 Game Gears ! It is the right place to find useful tools to boost your game development. There is no need to reinvent the wheel, all you need is a place to find what you have been looking for. Enjoy!

FIVe3D – Flash Interactive Vector-based 3D

2010-05-05T07:04:02+00:00

If you are looking for something different to make you game or Flash app looks better than the rest then you must take a look at FIVe3D. It is an open source code for the conception of interactive vector-based 3D animations.

It is licensed under the MIT License. One of my favorites demos is the Fluo Board.

AS3-Utils

2010-04-23T01:08:41+00:00

Sometimes I find myself solving the same problems again and again on several different projects. Definitely there is no need to reinvent the wheel, you just have to use the right tools.

Theses days I found a perfect help on that subject. AS3 utils is a set of useful function that solve common problems such as randomizing or summing the values of an a array. All functions were collected from several open souce projects from the Internet, so there is no unified license.

BulkLoader – managing multiple loadings in AS3

2010-03-09T07:02:28+00:00

One of the most common tasks in game development is the assets loading process. You have two options: 1) ship your game as a single 45Mb SWF file filled with sweet and compressed-to-the-bones images/sounds or 2) load all those assets separately and on demand.

Sometimes the first option is your best shot, but for casual online games the second one is more suitable. Multiple loadings in AS3 can be a pain, because there are several file types to load (wave, JPG, mp3, GIF, swf, etc) and there is no single way to load them all.

So far my best approach to solve this problem is called BulkLoader, a library for managing multiple loadings with AS3. It is licensed under the MIT License and has amazing features:

Connection pooling.
Unified interface for different loading types.
Unified progress notification.
Events for individual items and as groups.
Priority
Stop and resuming individually as well as in bulk.
Cache management.
Statistics about loading (latency, speed, average speed).
Various kinds on progress indication: ratio (items loaded / items to load), bytes , and weighted percentage.
Configurable number of retries.
Configurable logging.
Various assest types (XML, NetStreams, Swfs, Images, Sound, Text Files)

Design goals:

Minimal imports.
Few method to learn.
Consistent interface, regardless of content type.

BulkLoader gracefully handles progress notification in these use cases:

Few connections to open: bytes total can be used instantly.
Many connections opened: progress by ratio
Many connections opened for data of widely varying sizes: progress by weight.

One of the things I like the most is that this project was created by a Brazilian fellow named Arthur Debert :). Thanks for this great tool!

Mrdoob stats – Actionscript performance monitor

2010-03-05T00:14:16+00:00

Create and develop a game is hard task, but optimize one is even harder. You can ruin a perfect game design and a beautiful artset by filling the source code with useless and/or unnecessary stuff. In order to keep things in control a performance monitor comes in handy.

Mrdoob stats provides a simple info box that will help you monitor your code performance. It can tell you the following:

FPS Frames per second, how many frames were rendered in 1 second. The higher the number, the better.
MS Milliseconds needed to render a frame. The lower number, the better.
MEM Memory your code is using, if it increases per frame is VERY wrong.
MAX Maximum memory the application reached.

It is another great tool to know what is happing under the hood.

Isometric AS3 game engines

2010-02-27T00:07:38+00:00

After Happy Farm and FarmVille attracted millions of user there is a lot of talking about isometric games. I’ve played several games featuring an isometric view then I’ve spent some thoughts around the idea of creating my own isometric game (or one for my company, developed during my inexistent free time).

Looking for isometric game engines, I found three great projects: FFilmation, As3isolib and OpenSpace.

FFilmation (MIT License):

Have a programming interface as small and easy as possible, no matter how complex the internal code is;
Rendering performance is a major concern when designing all the algorythms;
Graphic designers are able to work on the application’s ( game or not ) environments without any programming skills, visually, and with almost immediate previews of what they are doing.

As3isolib (MIT License):

Simple scene creation;
3 primitive types;
Base class for displaying user-created conten;
Plenty of styling option on vector based primitive;
Integrates well with a variety of tween engine;
Improved 3D isometric positional sortin;
Scene & view renderer classes geared towards performance optimizatio;
Performance caching of static and animated sprite asset.

OpenSpace (commercial, part of the SmartFoxServer platform for multiplayer games):

Engine and framework for rapid development of multi-user virtual worlds and MMO communities;
Customizable tiles’ aspect ratio;
Tiles Elevation
2D objects in a 2.5D world
Backgrounds and foregrounds
Scrolling
Advanced pathfinding
Powerful avatar management
Advanced map interaction system
Exhaustive documentation
Complete Map Editor

If you were planning to develop an isometric game, you just found your first step.

Improve your game with particles

2010-02-13T06:08:37+00:00

When I play a game, I like to see all those flying particles popping up on the screen. Casual games make heavy use of this resource, sometimes more than what is considered healthy.

A particle system adds dynamism to the game and makes it feel alive. Where is the fun of blowing up an enemy base and see just a few flames as a reward? Players want to see lots of things flying around and sparkles shinning towards the camera. Flash gamers are no exception. In order to add particles to your game, you can use two free particle systems (both use MIT license): Flint and Stardust.

Flint is an open-source project to create a versatile particle system in Actionscript 3. The aim is to create a system that handles the common functionality for all particle systems, has methods for common particle behaviour, and lets developers extend it easily with their own custom behaviours without needing to touch the core code.

Stardust was inspired by Flint, but it has its own set features:

Supports 2D and 3D particle effects.
Easy to extend for custom initializers, actions, fields, deflectors, clocks, and 2D/3D renderers.
Includes 3D extensions for ZedBox, Papervision3D, and ND3D.
Includes a native 3D renderer.
Supports particle masking (particles can be masked out for actions).
Uses linked lists and object pools to improve performance.
Gravity and deflector simulation.
Action triggers (for creating complex conditional particle behaviors).
XML serialization.

QuickBox2D: AS3 physics engine

2010-02-08T09:54:33+00:00

The first time I saw a really convincing physics engine working on a PC game was during a Half Life 2 session. All that Havok physics created an unique game experience. Luckily the use of physics inside games has grown and now we have a wide range of tool to use, even in Flash games.

QuickBox2D is one of them. It is a mini-library created to work with Box2DFlashAS3, which is an AS3 port of the famous Box2D C++ physics engine. The main purpose of this library is to significantly simplify instantiation of rigid bodies and provide a simple way to bind them with custom graphics.

You can start with QuickBox2D by reading this great kick off tutorial. It explains the engine itself and demonstrate how to use some of it’s features.

OnePress Community

2010-02-03T07:23:30+00:00

I see lots of open source projetcs using Worpress as a blog platform, phpBB as a forum solution and Mediawiki as a wiki. I like them all, but maintaining them separately with no integrations is a pain. It’s great when you register to a website and you can use the same fresh new account to comment on the blog, reply to a forum thread and/or contribute to a wiki page.

Excluding the wiki part, there is a tool that makes it all possible. OnePress is an integrated website and forum solution. It is, simply, a WordPress theme to serve as the foundation and framework for your web site and online community.

Some of it´s cool features:

Seamless integration with phpBB, complete with unified login and widgets to display forum posts on site.
Widgetized WordPress layout with drag and drop interface to quickly build site.
Professional featured content widgets to display important posts with prominence.
Easy to use backend enhancements for editing OnePress widget content.
Highly optimized page rendering process for optimal performance.
Built with WordPress 2.7 and child themes in mind. Flexible hook system for full theme customization.

AS3 game engines

2010-01-30T09:10:08+00:00

I like to write my code from scratch, but it does not mean I want to reinvent the wheel every single day. This is one of the reasons why I like to use engines to code games.

Sometimes the project has it´s own specific features and it requires a completly customized code, but most of the time it´s all about the same things: test input, check collisions, update a bunch of elements and finally render them all. Looking for a tool to do those tasks for me, I found two free and open source game engines: PushButton and Flixel.

PushButton is a very modular game engine licensed under the MIT license. It has core functionality as resource manager, logger, debug monitoring, serialization, time management, globally named objects, etc. It also has a set of components that make the engine even better:

Physics based on Box2D;
Gameplay components: health, teams, state machines;
Sprite-based and SWF-based 2D rendering;
Tilemap system;
Pathfinding library;
Basic networking. Pass events to/from your servers, do XMLRPC/JSON Web API requests, etc;
Awesome UI capabilities via Flash – localizable, stylable/themable, internationalizable.

Flixel is collection of AS3 files that helps organize, automate, and optimize Flash games. It is also licensed under the MIT license and has a great set of features:

Really fast renderer (5000+ sprites on modern PCs);
Tilemaps;
Particle systems;
Global sound system with volume hotkeys, looping, panning, etc;
Parallax scrolling (free/multi-directional);
Built-in 2D box-based game physics (not Box2D);
Fast text rendering;
Retro style zoomed rendering options (2x pixels, 3x pixels, etc);
Works great with non-pixel art too, with support for rotation, scaling;
Composite multiple sprites using blending modes to create sweet lighting effects;
Does not require the Flash IDE, works best with free tools like FlashDevelop;
Organizational classes like game states;
Simple buttons;
Utilities for looping music and playing sound FX;
Simple special effects like screen flashes and fades;
Save game data between sessions using a local shared object.

Reading about them gave me the idea of writing my own game engine someday. Maybe some raining day I give it a try

• Really fast renderer (5000+ sprites on modern PCs)
• Tilemaps
• Particle systems
• Global sound system with volume hotkeys, looping, panning, etc
• Parallax scrolling (free/multi-directional)
• Built-in 2D box-based game physics (not Box2D…yet, anyways)
• Fast text rendering
• Retro style zoomed rendering options (2x pixels, 3x pixels, etc)
• Works great with non-pixel art too, with support for rotation, scaling
• Composite multiple sprites using blending modes to create sweet lighting effects
• Does not require the Flash IDE, works best with free tools like FlashDevelop
• Organizational classes like game states
• Simple buttons
• Utilities for looping music and playing sound FX
• Simple special effects like screen flashes and fades
• Save game data between sessions using a local shared object

Simple and powerful intranet

2009-10-18T00:10:56+00:00

These days I was looking for intranet solutions and I luckily found Open Atrium, an intranet in a box that has group spaces to allow different teams to have their own conversations.

OpenAtrium is built on top of Drupal, has a nice design and a useful set of features:

Blog: A classic blog for each group that has commenting, file attachments on both the post and comments, and granular notifications.
Calendar: A calendar that lets you quickly add events, suck in iCal and other calendar feeds, and support single or multi-day events.
Group Dashboard: Mini widgets give you a snapshot of all the activity happening across your groups.
Documents: A simple online handbook that lets you collaborate on documents, store and compare revisions, attach files, and once you’re done print out the final copy.
Shoutbox: Kind of like a private twitter, the shoutbox lets you share short messages, links, and information with just the people in your group.
Case Tracker: A full ticketing system that lets you assign to do’s and create unlimited projects within each of your groups. The case tracker also lets you classify the to do, give it a priority, and manage its status.

For small companies, it is an efficient tool to create/maintain an intranet.

Flash instead of Powerpoint?

2009-10-16T00:20:24+00:00

Probably I’ve spent several hours editing and arranging pictures to create a nice Powerpoint presentation. Even though the Microsoft product is a great tool, I do not like the final result. It seems unfashionable, too poor and/or simple.

This is one of the reasons why I like image sliders developed using Flash. I look at them and imagine how wonderful life would be if I could easily use it and some lines of text in a .txt file to create a presentation. Nice graphics, beautiful font rendering, smooth effects (including blur and glow) and maybe some physics, why not?

Trying to make my dream come true, I found two amazing image/content sliders in Flash: MegaZine 3 and CU3ER. The first one is an open source pageflip/flashbook engine, written completely in AS3.

The other one is a content slider with 3D transition effects, such as spinning.

Certainly those two projects have lots of cool features and they can perfectly fit into a wide range of uses. If I have the change to save some time for my personal projects, such as my own Flash slide presentation, I will use MegaZine 3 and CU3ER for sure.

SWFConsole: enhance the power of your Flash games

2009-07-10T22:51:03+00:00

Sometime ago I was working on a Flash game and I had to output some information to the console. That’s a very easy task when you use trace() and the Flash IDE, but things get a little harder when you need to output text inside the browser.

Looking for a tool that could help me output text, I found SWFConsole. It is a free developer tool for Flash AS3 projects that gives you output in all environments, not just the IDE. You can type commands in order to manipulate Movieclips in the stage, such as myMovieclip.alpha = 0.3.

SWFConsole also has a built in resource monitor that shows FPS and memory usage, pretty useful for game developers. I miss some features as listeners to handle custom commands and a method to “enable/disable” the console instead of showing or hiding it, but it does not make the tool less useful.

If you are a Flash game developer, SWFConsole can make your life easier!

PHP and PDF in pure Javascript

2009-06-03T23:55:23+00:00

Javacript is the very first base stone concerning web 2.0. In the past, I always heard bad things about Javascript, but I guess all of them were said because Javascript was being used by the wrong people, in the wrong place and at the wrong time.

A lot of sites use huge Javacript libs, each one performing nice things, such as HTTP requests, animation effects, generation of RIA content, etc. Javascript is so famous now that several things have been ported to it, such as encryption algorithms.

I have found two of those Javascript ports that can be really useful, specially if you are a PHP developer (just like me): PHP.JS and jsPDF.

PHP.JS is an open source project in which you can use PHP functions client-side, in pure JavaScript. jsPDF is an open-source library for generating PDF documents using nothing but Javascript.

FlashDevelop: a powerfull and free AS3 development tool

2009-05-31T16:22:10+00:00

If you work with Flash like I do you probably have said a bunch of bad words while you were coding AS3 using the native Flash IDE AS editor. I like Adobe, I really do, Flash can do amazing things and the IDE is getting more and more powerfull, however as a AS3 project manager, the Flash IDE sucks.

I could have saved tons of working hours if Flash IDE had some sort of smart code completion, or if it had a better project manager panel (a simple one that hides the SVN directories, for instance). The logical choise for me would be change to another IDE or methodology, such as Flex Buider, but sometimes I’m binded to the Flash IDE because I can’t use a different approach.

Tired of wasting my time coding like that, I’ve decided to search for a better AS3 development tools. Thanks to the open source community, I’ve found FlashDevelop, a free and open source ActionScript 2/3 and web development environment. It seemlessly integrates with Adobe Flash IDE{.postlink}, Adobe Flex SDK{.postlink}, Mtasc{.postlink}, Haxe{.postlink} and Swfmill{.postlink}.

Some of the features:

AS2 Project management{.postlink} with seamless Swfmill and Mtasc integration (using a portable standalone command line tool).
Advanced ActionScript 2 and ActionScript 3 completion & code exploration{.postlink} with automatic classpath detection (even without project).
Smart contextual Actionscript code generators.{.postlink}
SWF and SWC classes and symbols exploration.{.postlink}
Test movie in Adobe Flash IDE and with clickable error results (Flash CS3).
MTASC compilation/code checking with clickable error results.
Types Explorer.
Automatically cleans ASO files of modified AS2 classes.
Files explorer (can create Flash 8 Trust Files for you).
Automatic JavaDoc creation from methods.
Smart Actionscript help websearch on F1.
Jump to class/member declaration on F4.
XML, HTML/PHP, JS, CSS code highlighting.
Multibyte character encoding.
Program menu customization with XML files.
as2api GUI for documentation generation.
Snippets, lines bookmarks, code folding and zoom.

FlashDevelop has enhanced my production cycle and I think it can do the same for you. Download it now and enjoy!

Webapps brought to the Desktop

2009-05-17T12:00:27+00:00

Some years ago, the only thing that came to my mind when I heard the word “web” was “very simple websites”, a bunch of bytes available for browing. Google was not even born at that time and everyhing was focused on desktop applications. If your application was able to connect to the web, then it could update itself in a easy way, nothing else.

The main flow was to bring every single business plan into the desktop world: office stuff (such as Microsoft Office), e-mail (Outlook), image, music, movies, etc. In the web world at that time, Javascript was an ugly word to be fired and Flash was just a way to make things look a little bit better.

The world is different now and ironically it seems to be the opposite of what it was in the past. Instead of bringing things into the desktop, the idea is to take them to the cloud, make them available on the web. This is happening very fast, but sometimes it’s useful to have some desktop behavior in a web app, such as offline access to your e-mails.

Why can’t we use the best things of those two words (web and the desktop)? Even better, why can’t we use our web development knowledge to create hybrid apps that work in those two worlds? In fact, we can, and a lot of people have noticed that.

The first one I can recall is Adobe with Apollo, on March 19, 2007. Apollo, after named to Adobe Integrated Runtime (AIR), is a cross-platform runtime environment for building rich Internet applications using Flash, HTML or Ajax, that can be deployed as a desktop application. A very powerful tool able to create nice apps featuring half desktop half web blood.

Right after Adobe, Mozilla started working on a similtar idea and on October, 2007, Prism was born. It is open source, like all the things Mozilla does, and it splits web applications out of the browser and run them directly on the desktop. Prism development is not fast as Adobe’s AIR is, but they are moving forward.

These days I’ve found a brand new tool like those previous ones: Appcelerator Titanium. As far as I could see, it works just like AIR, but it is open source. I read a few forum threads at Titanium forum and some developers said their Titanium apps were running faster then their AIR versions. Another very nice thing is you can use sevel languages to code your application, such as PHP and Phyton instead of only HTML and Javascript.

If you were thinking about developing an desktop-and-web application in a easy way, take a look at those options above. I’m sure you will have a lot of heavy weapons available to make your ideas to come true.

IE6 has already fulfilled its destiny, it’s time to upgrade!

2009-04-28T23:02:46+00:00

One of the most annoying thing I did during the development of our web projects was to keep our apps running smooth in a wide range of old browsers. Not too many years ago, there was only one “king” in the browser’s kingdom: Microsoft Internet Explorer. King is a little bit unappropriated, however on February, 2005, IE 6 was pumping the web engines with a market share of 82.79%, what is a quite impressive number.

Excluding the security problems, the non W3C compliant behavior and other issues, IE6 as the only major browser would be a great deal to all web developers. The existence of just one browser means few environments to test and few compatibility if/elses. The web-developers burden, however, was far from being released.

In 1996, Opera was first released publicly with version 2.0. Coming next, Apple first released Safari as a public beta on January 7, 2003. Following the flow, in November 9, 2004, Mozilla came up with Firefox 1.0. The last one to join the party was Google Chrome, released as a public beta on September 2, 2008. With the built-in markup madness that HTML allows and with no clear rules for how a browser should behave, the web development became a nightmare.

Luckly things got better and the development of major browsers started to have its foundations over W3C standards and performance worries. Every new version of each browser introduced a set of brand new stuffs, including security improvements and higher Acid scores. Everything would be great, except for one huge problem: IE6, an old and obsolete browser, is still widely used!

That problem drastically increases the complexity of web apps, because developers, in order to ensure the website will look fine, have to workaround all the stupid things IE6 does. As the WordPress guys usually say, “code is poetry”; in my opinion IE6 compatibility code is classified as a bunch of ugly words within a rhyme. It’s time to move on, let IE6 go!

To tell that to your users, a good approach is the ie6 upgrade warning. It is a little script (7.9kb) that displays a warning message politely informing the user to upgrade the browser to a newer version (links to newest IE, Firefox, Opera, Safari, Chrome are provided).

Make the Internet a better place, let old things in the past and move on to the new ones. Upgrade your browser.

Profiling and debugging PHP

2009-04-26T01:59:19+00:00

Reviewing the code is an important task every programmer must (or should) perform. Sometimes the program you have just coded looks nice and fast, because all the tests you have performed using your well-controlled devel0pment sandbox showed no errors.

Unless you are a god when programming, you may have left some little performance tweaks behind. Most of the time you can replace several method calls with the returned value stored in a variable, or avoiding nested for/whiles, or freeing a result set in order to save some memory, etc. In the end, all those tweaks can make the difference between a smooth user experience and an extremely painful development problem.

If you are a PHP developer, you can use the free PHP Quick Profiler (PQP) to help profiling and debugging your code. No more echoing vars, objects or queries in order to find performance mistakes. Using an automated tool to show you what is going on, you can save a lot of time and ensure your app is stable and fast. I read about PQP at WebAppers these days. They also have a screenshot (below) and a link for a demo.

If you want more options for profiling and debugging, I recommend Xdebug, which is a very powerful tool. We have been using it at Decadium for a long time. Some of the features include stack traces and function traces in error messages (with full parameter display, function/file name and line indications), information about memory allocation and protection for infinite recursions.

Xdebug is also free and has support for Windows and Linux.

Hello world!

2009-03-27T20:48:47+00:00

Welcome to my personal website! Here you can find some information about my work, about the stuff I’ve created and about the useful (and not so useful) texts I read every day. I hope you can find here something cool or, at least, something able to help you somehow.

Feel free to mail me at any time for suggestions and enjoy the lack of content!