cook, write, code, photograph.

Well, besides being a fancy name "Senior", there's more than years of development experience.

Yes, I know, seniority comes with aging, and responsibilities. But there's somethings we can't forget when thinking about "Senior".

"Years of experience":

Yes, I also consider someone a Senior when they have many years of experience into something, like a "Senior Web Developer" would have years of experience in "Web Development", whichever would be the language (s)he choose to work with, either it's Python, either it's PHP, or Java, it's all Web Development. But here is the common mistake people do, unless you say you are a "Senior PHP Developer", you can't choose one language to master into, and finish your life within this sole language. Development, either it's social, web, desktop, mobile, is a mutant thing, and sometimes, you need more than one language to solve some challenge.

Let's take an example:

Back in the days of PHP 5.1, 5.0, that PHP didn't had support to WebSocket, as we have today with Rachet, we were building this chat feature for a social application, and of course, the hype of the moment was "WebSocket this, WebSocket that, and blah blah blah", so we needed something to work within WebSocket, and finally replace all the COMET code we had here and there, Python with Tornado came to rescue. We built a WebSocket handler, which handled the socket opening, sending and receiving messages from every user of our application, rerouting these messages to the recipients and then forwarding all to PHP code so we can parse these messages, and insert them into database, and make all the notification code, and the list goes on.

Why did I told you guys this example? Simple, Seniority comes with choosing the right tools to certain types of challenges, even if it's some brand new technology, you have the feeling that this could solve one part at a time of your challenge.

We didn't discard PHP, and started to migrate the whole code of our application to Python, all we did was building a component that used Python to serve as a WebSocket server, and do all the routing part, so we could parse this at PHP level, without having to write a whole WebSocket Stack at PHP.

You said there were other things than years of development, what else?

Yes, I said. A Senior guy will eventually, or even, all the time, lead a team. Yes, that's what I said: "Lead a team".

So think with me, seniority comes when this guy or girl, can handle it's own taks and at the same time help guiding and instructing people from your team, and sometimes, from other teams.

That means, you have to know the tools you use, the tools you need for your daily challenges, and also, the ones your colleagues needs for their challenges, the ones your interns needs to their tasks, also, you should be able to help them within finishing their tasks on time.

Yes, seniority means you can be blamed for someone else mistakes, and you have to be mature enough to keep calm, and work on some solutions so these mistakes won't repeat again.

"Keep it simple, stupid"

I don't know if you guys have ever heard this expression, K.I.S.S, not, it's not the rock band, it's a "principle". With seniority, you learn that this is the most common thing you will need to use on a daily basis.

Seniors knows that sometimes, writing code to fix some features can't take the costs of being fancy, after all, the whole code you will be writing is to fix some feature.

Practical Example:

You have a coffee machine, and the software that makes you the coffee is freezing when you says to the machine "build a Latte".

Senior will simply fix the part that the milk ain't being insert into your coffee, after all, this was the piece that was freezing the machine. Quick and dirty fix. Simple, and functional.

Yeah, you could think, oh, what a lazy person.

Yes, but all this product needed was a fix on the Milk function, and that's all our senior needed to do.

Now that this fix is released, (s)he will work with the team, and start searching for new bugs so they can fix them before the customers discover'em.

No fancy code, no fancy fixes, just simple code to this especial failure.

"Not me, we"

Seniority means that you replace the "me" pronoun by "we", after all, you lead a team, you aren't solo, there's people with you, working with you, sharing their feelings, sharing their knowledge.

So, forget the "I", "Me", "You", start using more "We".

After all, seniority also means, "We did that".

That're some of my feelings about being Senior, hope you start to think about'em when leading your team, or doing some task for this great project.

And, I'm happy that you got so far at this text, hope you liked it. For those who didn't got the overall idea, I will try to sumarize them bellow:

Years of experience is important, but be realistic with your terms, don't say you are a "Senior Rock Engineer" if you only spent the last 10 years just breaking rocks. You need to know a little much more than breaking a rock so you can be a "Rock Engineer"

Keep calm, and help others, most of the time you will help other people, from your team, or from elsewhere they are. And most of the time, you will get the blame if your team fails, so you have to be calm, take this, and be sure this won't happen again.

"Keep it simple, stupid", helps you writing code that actually do real things, it's not about improving your code with tons of features, if all we need is a simple "break the rock" feature

Forget "I", and "Me", after all, you are "We"

This gist is about a sandbox plugin loader I made myself, it's a simple one, just redefines the functions you forbid, so you can include the plugin code (better if you checkout the code first) and rest assured that the plugin can't access other files, use it with open_basedir setted up

One beautiful thing about computer programming are the differences from OS to OS, from Windows, to *nix, and so on.

When we are writing cross-platform code, as in my case where my dev machine is a Windows 10 machine, and our production servers are all Linux, we have some little things that you need to go on with an IF or some constant from the Programming Language or the toolkit.

Today I was surfing the web, and got into an article about QDir::separator() property (Yes, Q Toolkit, Qt). So the article was explaining why this property is harmful and so on. Well, at the begging of times, Windows only accepted inverse slash as a directory separator, this and only this, so, when we wanted to navigate through CMD or passing a path as an argument, there was the handy inverse slash. On the other side, on *nix systems, the slash was the directory separator. That caused some languages to insert some constants to help you programmatic create file paths, and that was good.

Time goes by, and Windows started to understand the slash separator as a directory separator too, you can see this working when you open a CMD shell, and starts to navigate.

And here goes the bug, now-a-days when you consider testing some condition with this constant, you can trigger platform specific bugs, see this example from the qt article:

void testFindBiggestFile() {    QString result = findBiggestFile(mTestDir);    QString expected = mTestDir + QDir::separator() + "file.big";    QCOMPARE(biggestFile, expected);

}

This test passes on a Linux system, but fails on a Windows system: findBiggestFile() returns a path created by QFileInfo, so assuming mTestDir is C:/build/tests, result will be C:/build/tests/file.big, but expected will be C:/build/tests\file.big.

See how easy is to get some headaches? You would be surprise how things can go pretty wrong when you try to be platform-agnostic.

This applies to PHP too.

System remains stable, no big deals yet.

A new daemon was inserted at PayGate, it fetchs some web page, parses data, and inserts into database updated values, PHP 5 - 10,1 MB of memory, PHP 7 - 6,8 MB of memory.

Garbage collector works slightly different, variables that should be freed weren’t till I called my self gc_collect_cycles

Everything sees fine, my WampServer didn’t support natively PHP 7 binaries, so, I disabled Apache, and used the Embed HTTP Server within PHP.

Smarty was little outdated, upgraded to latest version from the git release, everything know runs smoothly.

Still searching for bugs. Some items from the incompatible page gained my attention, pretty sure that something will break.

From JustinaMalkas: “If after PHP upgrade you're getting error "PHP Fatal error:  Cannot declare class error, because the name is already in use ...", you will have to rename your "error" class.“

From WikiPedia (https://en.wikipedia.org/wiki/Application_programming_interface):

In computer programming, an application programming interface (API) is a set of routines, protocols, and tools for building software applications. An API expresses a software component in terms of its operations, inputs, outputs, and underlying types, defining functionalities that are independent of their respective implementations, which allows definitions and implementations to vary without compromising the interface. A good API makes it easier to develop a program by providing all the building blocks, which are then put together by the programmer.

Also from WikiPedia (https://en.wikipedia.org/wiki/Representational_state_transfer):

In computing, representational state transfer (REST) is the software architectural style of the World Wide Web.[1][2][3] REST gives a coordinated set of constraints to the design of components in a distributed hypermedia system that can lead to a higher-performing and more maintainable architecture.

To the extent that systems conform to the constraints of REST they can be called RESTful. RESTful systems typically, but not always, communicate over Hypertext Transfer Protocol (HTTP) with the same HTTP verbs (GET, POST, PUT, DELETE, etc.) which web browsers use to retrieve web pages and to send data to remote servers.[4] REST interfaces with external systems using resourcesidentified by Uniform Resource Identifier (URI), for example /people/tom, which can be operated upon using standard verbs, such as DELETE /people/tom.

So, what does these terms has to do with me? Well, I’m a web developer, and in this busy world we live on, we constantly needs to connect with other systems, and make then parse data. Well, this was a trouble at the ancient time, we didn’t have a standard way of doing it, and we had to parse web pages, so we could fetch results, simulate user interaction so that we could insert content and so on.

When I’m working with PHP and our projects I tend to use a PHP class, slightly modified, that parses a list of classes using PHP Reflection class, and it’s comments generates the mapping, example:

https://gist.github.com/tryvin/5c1fc37096b575d63c2a

You see the pattern, where we map HTTP methods into a CRUD (Create, Read, Update, Delete) handler, so, everyone will know that to create a user they just need to POST into the url /users/new, to get a list of all users they connect with /users, and to delete some user, they use the DELETE HTTP method into the url /user/<userId>.

Why is this easier? Think that you only need to create four methods, that do some simple http requests, and you are all set to interact with this server. Instead of doing a request, then a scrap, then ordering the data, or simulating a user form, and submiting this data, then scrapping the response.