I have read tutorials for adding German, Portuguese, Chinese, and Spanish. In all of them, the special characters are used directly in the translation files without any issues, in my case that didn’t work out at first.

I couldn’t use the special Spanish characters directly in the translation files. I was having always an error similar to “‘ascii’ codec can’t decode byte 0xc3 in position 18: ordinal not in range(128)“.

Are you having issues with accented or special characters in your translation files? Cannot you show characters like ß, ü, or “你好”? Let me help you with the problem.

My Project Setup

I have a Django project with multiple applications, and for each application, I had to add its translation files. Because of the numerous templates, views, and APIs, I wanted to translate one application per time. Test the translations slowly for every feature and jump to the next one.

When I read the tutorials, I didn’t generate the .po files or the folder structure automatically. I tried, but the generation was giving me some issues, and because of my approach, I decided to create the folder structure and the files by hand.

If you look at the tutorials carefully, they usually create the files using makemessages. This utility creates the folder structure in all the applications and looks for the keys that need to be added depending on your application.

The use is pretty simple, execute the below command with the language you would like to add, in this case, German.

django-admin makemessages -l de -i venv

And it will create the folder structure for all the applications, together with all the keys that need to be translated. The result will look like this:

English and Spanish are present, and their translation files are compiled in this case. After the execution of the above command, the structure for the German language was created. The new file and folders are the ones within the highlighted yellow square.

My step-by-step technique

As said before, my project has multiple applications, concretely eight applications. It is a side project I use for myself, but it is still not publically available for other users. I set up the internationalization and started with the home page. I added the files only for the main application, translated the templates to Spanish, and then jumped to the views.

In the templates, I use trans, so it is pretty simple to have it working. Just the i18n library at the top of the template and start creating your translations:

{% extends 'base.html' %}

{% load i18n %}

...

<h1 class="display-5 fw-bold">{% trans "bukios_home_welcome_title" %}</h1>
...

Don’t forget to add the load i18n in every template where you use the translation functions. It is not imported from other templates, although you extend from a base template or include them.

After I added a few keys, I tested the feature in isolation, without looking at texts from other applications or features. One feature translation and application at a time. The command that you will need to have the translations working in your templates and not seeing the keys is:

django-admin compilemessages -i venv

This allows you to have both languages working, but how? I moved the English texts to the translation file, checked it worked, and added the Spanish translation. Two steps, one seeing that everything continued working in English and a second step checking that all the things appeared in Spanish.

First Issue: the templates

In the templates, I found my first problem. The Spanish special characters like the accented vocals were not working using them directly. I looked into the different tutorials and although everybody was using them directly in the .po files, it didn’t work for me. Each time that I added an accented vocal or other Spanish special characters, the compilation worked but when I tried to look into the web to see the changes I got an error similar to this one:

The hint the above error:

a Unicode error with some text, probably something like “…etición in…”

After looking a bit I found that “ó” was not working but “ó” was. So, I decided to encode all the special characters. It was not a big deal for Spanish, but it may be impossible for Chinese.

Second issue: the messages

After I finished with the templates, I continued with views.py. They don’t use the same function, there you use gettext(…) or similar.

But it took me some time to figure out that gettext was not able to translate á to á, it was not able to decode the HTML codes in the translation files.

The solution, or how to set the charset

The problem is clear, but let me briefly summarize it. In Spanish, German, or other languages the special characters are not shown as expected in the views. The HTML code encoding is not a nice or right solution. The gettext function does not decode the HTML codes at all, they are not solving partially your problem. Why partially? because for example I tried something like ‘你好’ (that means ‘hello’) and it didn’t show up either.

The problem is not happening at the compilation time, it is happening at the use time. In the browser, you will see something similar to the below screenshot.

The deep analysis was giving me some insides, the Unicode was wrong at some point. I tried at the application level, at the HTML level, and at the translation files level. I failed at all the levels with all my changes. My setup was correct, the same as in every tutorial, with no differences. Almost, no differences.

How did I find out the error? After reading, testing, and failing so many times around the Unicode, the encoding and decoding of the gettext function, I decided to debug the library and find out how it worked, where it was failing, and what was the code doing at that level.

The clue

I put a breakpoint at line 458 in the gettext.py file, stop the application there and execute some tests when the key had some accented vocals

/usr/local/Cellar/python@3.9/3.9.16/Frameworks/Python.framework/Versions/3.9/lib/python3.9/gettext.py

The key was the charset value, debugging I found out that it was ‘ascii’, not UTF-8 as I was expecting and as I was setting up in a lot of places. The value that I was adding after reading some StackOverflow similar cases, was not properly coming here. I tried with UTF-8.

Eureka! It worked!

At this point, I had some success, but still no solution.

The solution

I added UTF-8 in multiple ways and in multiple files, but nothing looked working. I analyzed the tutorials one by one, reviewing again the setup, the views, the imports, using ugettext (deprecated and removed in Django 3), u’your text’, …

Nothing worked.

I took the official documentation, and read it from the beginning, carefully, but I wasn’t able to find how to fix it.

At this point, I had created the English files, and the Spanish files for the complete application all the translations worked fine for the templates, but not the translations coming from the views using gettext. Still, I wasn’t translating the javascript files, but those use gettext too. They could wait until I fixed the issue.

And then, I found a post on medium, Giorgi was doing the same as others, he was using English, Russian, and Georgian. But there was one thing different, he showed a .po file with something like a header, something similar to the below code.

msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2020-01-28 14:45+0400\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"Language: \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n!=1);\n"

Look at the Content-Type line, there is a charset set to UTF-8 there.

I tried and the magic happens. The accented characters, the opening of the exclamations, our famous ñ,… all of them started to show up.

The key is the line where the charset is set, I tested removing the others and the translation issue still worked.

Conclusion

Look for a tutorial that fits well for you and start setting up i18n in Django. Also get the documentation close to you and read it. My recommendation is that you should use the special utility libraries from Django at the beginning, until you learn all the details, which will avoid you problems. As you have read, I have described you how to set up the charset to UTF-8, for your translation files and how to dive deep to understand what is going on in the libraries.

In my case, not using the makemessages utility at the beginning, letting the library to set those values automatically was the issue. More if you think about it, that in all the tutorials I was reading, they clean up the files and remove these key values completely. In some tutorials, you are able to see some dots (‘…’), but it is difficult to figure out what they mean.

Remember to add the charset in the way that I have described. It was not easy to find out how to add it to the translation files.

There are more values that I have kept for now, I will fine-tune them later as soon as I see the impact that some of them will have in the different libraries. For the time being, they are like documentation of what it is possible to set up in the translation files.

The post Django i18n without Unicode issues appeared first on jenaiz.com - I think..

Did you know those strategies were used for memory allocation? Do you know whether it’s possible to disable the garbage collector or not?

From version 2, Python started to use two different strategies for memory allocation reference counting and generation garbage collection. Prior to that, the only strategy used was reference counting.

Reference Counting

In this technique, it keeps the counting of the references to an object. When a new reference is created, the counter gets incremented by one, when we remove a reference the counter decrements by one.

Of course, every object created in Python needs to keep the counter updated continuously. In case the reference counter is 0, the object is eligible for being garbage collected.

Let’s create three references to the object “my object” and check the reference count of the object.

>>> import sys
>>> a = "my object"
>>> b = a
>>> c = a
>>> id(a)
4377801904
>>> id(b)
4377801904
>>> id(c)
4377801904
>>> sys.getrefcount(a)
4

id(…) shows up the unique integer that represents the object of the reference. And sys.getrefcount(a) returns the reference count of the object (“my object”). The count returned is generally one higher than we expected, because it includes the temporary reference as an argument to getrefcount().

Below there is a representation of the above code.

If we remove one reference, the counter gets decremented by one.

>>> del(c)
>>> sys.getrefcount(a)
3

If we remove all the references, the counter will be 0 and the object will be eligible for the garbage collector to erase it.

Something curious is that the common values had more references count than I expected. This is because others reference them at the start-up of the interpreter. For example, I created a reference to 1 and found out a few hundred references count to the object. My recommendation is to create a special number or string, that will help you to understand the use of the getrefcount(…) method.

>>> h = 1
>>> sys.getrefcount(h)
601
>>> h = 3.14151692
>>> sys.getrefcount(h)
2

Also, if you create two objects with the same value, they don’t get the same ID, because they are not the same object. You can check their unique IDs and the reference count of the objects.

>>> a = 1234
>>> b = 1234
>>> id(a)
4484904240
>>> id(b)
4484904080
>>> sys.getrefcount(b)
2
>>> sys.getrefcount(a)
2

A benefit of using reference count is the eligibility to erase an object from memory as soon as it has no references.

It also has some drawbacks. It can be really inefficient, particularly in a naive multi-threaded implementation. And it is not able to handle objects with circular references. For those cases, Python applies a second algorithm called generational garbage collection.

Generational Garbage Collection

This algorithm divides the objects into different generations based on time allocation. And it can apply different policies to each generation.

Python creates three generations at the start-up of the application. New objects go to the first generation, if they survive the recollection, the algorithm moves them to the second generation. The same will happen in this generation, the objects are collected or moved to the third generation. In that generation, the objects will stay until the program ends.

Each generation has a threshold, when the list of objects exceeds the threshold, Python runs the garbage collection process.

One of the drawbacks of this technique is that usually fails to remove long-living garbage, although they do a good job with the newest objects.

Is it possible to disable the garbage collector in Python?

It is possible to disable the second algorithm, the generational garbage collector, but it is not possible to disable the reference count algorithm.

Below there are a few methods from the gc module that can help you.

>>> import gc
>>> gc.isenabled()
True
>>> gc.disable()
>>> gc.isenabled()
False

Disabling Python generational garbage collector will not show you less memory use in your application, because Python generally doesn’t release memory back to the underlying operating system.

In case you want to dive deep into disabling the garbage collector, I recommend you to take a look at the post of the Instagram Engineering team, they were doing some experiments with the garbage collector and discovered some side effects with the disable() method for some third-party libraries.

Conclusion

Python uses two strategies for memory management, reference counting and generational garbage collector for cyclical dependencies. The second one is an optional garbage collector that is possible to disable. It is possible to take a look at the reference count of the objects, change the thresholds of the generations, and a few things more. I recommend you to take a look at the gc module, the sys module, or the garbage collector design documentation.

The post Understanding how the Python garbage collector works appeared first on jenaiz.com - I think..

There was no internet connection, the eth0 network interface was removed from the network interfaces and I discovered that there were some packages missing related to the network.

I am writing this post from a Post-Morten perspective. The details here are not something that I reproduced again to check that all the steps are perfectly fine, this is more a “how I solved, and I hope it will help you” than a step-by-step recipe. But believe it or not, after hours of trying things, the solution was easier than expected.

What was happening? What was the error that you would see?

The droplet lost the connection to the network, it was not responding to any request, the public IP was configured in DigitalOcean, but no domain responded, nor the IP address. Identifying the scenario wasn’t a big deal, you don’t need to be an expert sysadmin to notice it.

The only way to connect with my droplet was by using the “Recovery Console” nothing else worked. So I reset my root password and I logged into the droplet. The console only works with a US keyboard, it was really really slow, and writing or copying & pasting something or editing a file was a pain. Besides that, when I tried to change the keyboard, I figured out that some programs were missing.

How did it happen?

My best guess is that I accidentally delete some packages or they got deleted. Reading about what caused the problem for others most of them described some apt-get package purge that accidentally deleted the network tools. But others described that the issue appeared after the reboot because some packages were deleted without knowing the root cause of the deletion.

I thought about the last things that I did in the droplet and I remembered an upgrade of Python from version 3.8 to 3.9 and some clean-up of other versions in the droplet. I remembered because I got some troubles with Apache, mod_wsgi, pip, and Django application not being able to read the correct version of Python. Although the story would be for another post, I can say that I fixed the installation at the end, but I remember to make an apt-get purge. I guess that was the root of my Friday nightmare.

Anyways, the issue only appeared after the reboot of the machine, I didn’t notice anything before that.

Why was it so painful? And why did I decide to write it down?

I thought I had lost all the data in the Droplet. No easy solution to make a copy of the data at least without fixing the network interface. And then I realized that most of the tools that could help me were missing, which made it more difficult. All the posts that I was able to find told me how to solve it only partially because the final step always required a tool that was somehow missing in my system.

Missing tools: netplan, networking, ifconfig, cloud-init, …

The only tool available for me was IP.

Nothing worked…

The first thing was to discover what was happening. I checked that the network interface eth0 was not showing up, and I found a post in the forums where they described an issue similar to mine.

sudo ip link set eth0 up

“Cannot find device “eth0”

dmesg | grep -i eth

It gave me something similar to these messages errors:

virtionet virtio0 ens3: renamed from eth0
virtionet virtio0 eth0: renamed from ens3

The same that another person described here.

My system is an Ubuntu Server 20.04 LTS, so the details of the question could help me to set up the eth0 interface, but how the interface was waking up didn’t fix the issue. Later, I compared with a setup really working and there were some details different. 

In all the cases, the solutions described only worked temporarily because the solution disappeared after the next reboot. 

All the solutions that I have applied need to be translated to use the “ip” tool, it looks like “ifconfig” was removed a long time ago as a default package.

One thing that I tried and failed:

ip a add <PUBLIC_IP_ADDRESS>/<NETMASK> dev eth0
ip link set dev eth0 up

I also modified the /etc/network/interfaces file, adding the below information:

iface eth0 inet static
     address <PUBLIC_IP_ADDRESS>
     netmask <NETMASK>
     gateway <GATEWAY>

but I wasn’t able to execute:

sudo systemctl restart networking.service

so I wasn’t able to apply the configuration. There it’s when I have discovered that “networking” was not installed.

Nothing worked for me. 

Something strange was that the configuration files /etc/udev/rules.d/70-persistent-net.rules and /etc/netplan/50-cloud-init.yaml were there and well configured.

How did I finally solve it?

At some point in the long process, I found something interesting in the DigitalOcean documentation: You can restart your Droplet from a Recovery ISO and then have access to your Droplet hard disk. That was key to find the solution.

I followed the process to start up the Droplet from the Recovery ISO. Then I connected with the Droplet via SSH and then I started to work remotely. 

I added a nameserver editing the below file:

sudo vim /etc/resolv.conf

 I used one of Google well known DNS servers:

nameserver 8.8.8.8

And then, I mounted my droplet hard drive, as described on StackOverflow:

sudo mount --bind /dev /<chrootlocation>/dev
sudo mount --bind /proc /<chrootlocation>/proc
sudo mount --bind /sys /<chrootlocation>/sys
sudo cp /etc/resolv.conf /<chrootlocation>/etc/resolv.conf
sudo chroot /<chrootlocation>

In my case <chrootlocation> was “mnt”.

After that, I updated and upgraded apt-get:

apt-get update 
apt-get upgrade 

I am not sure if I would recommend the latest one.

After that, I decided to install all the tools that I found missing and could help me to fix the issue:

apt-get install netplan cloud-init ufw landscape-common

When I felt good enough, I decided to stop the Droplet, I removed the Recovery ISO and set it up to start from my hard drive again.

When the droplet started up, the network was restored and all was working normally. I was able to connect via SSH and my domains were working as before.

My thought here is that the configuration files were properly configured for all the tools, but the tools were missing. When the tools were restored, the system started to work again.

Lessons learned

Back up your server often. This is a cheap “production” server, where I have my blog and some Python applications running, and my strong recommendation is not to have this kind of setup.

One server with all the stuff is not a good idea. I do it because it is an easy way to play with things, but from time to time these funny stories happen.

The post How to fix a network connection error in a Droplet appeared first on jenaiz.com - I think..

A little bit of the history, our production system is a replica set of three nodes. When the issue is happening our system responses slow, in such situation what you feel is that the web is down, because you don’t receive answer in quite some time for some requests.

You know that the system is fixable easily because after you restart the node involved you get the system up and running normally again. The problem is that you have to delete all the data in the replica affected, and start a synchronisation from scratch. The first time was happening in the master node, the last day was happening in the slave node (a different machine).

Something good was that the last day when it was happening we was testing Newrelic and we got new information, not so much but something more. Some pictures that I have extracted from our Newrelic monitoring:

The CPU in use is growing a little in the point of the peaks:

But the real problem is the disk IO (not the network IO, as you can see in the pictures):

Here, there is a better graph about the problem with the IO and you can see that the writes was increasing in that time like the hell, using the 100% of the IO in the hard disk.

We don’t know the real reason, at the moment of write this post. Although, there is an old issue (fixed in 2.5.0), when mongod flushs the working memory to disk, it was having this particular problem.

I would like to write down all the things that we know in this point, maybe it will help us to find a solution in some point and clarify our theory of the “flushing data”:

• There was not so much users in that time in the website. The traffic and/or the consequences of that is not creating the issue, as far as we can see.
• The issue was appearing when the system is not doing so much things. It is not the most relaxed time of our MongoDB infrastructure, but there is not so many things going on in that particular time.
• The number of connections was growing from ~150 to 2000.
• The response times in the queries was growing to seconds ~20s or more
• If you create a graph with the response times of the collections, there is a log about “flushing data” (we use MMAPv1)

015-11-22T10:07:45.645+0100 I STORAGE [DataFileSync] flushing mmaps took 426819ms for 615 files
2015-11-22T11:13:31.755+0100 I STORAGE [DataFileSync] flushing mmaps took 429132ms for 615 files

• The node is still working for the master, but really slow for queries. It makes the web to be blocked because the driver doesn’t see the node down and it continues sending request to it.
• There was one of the web nodes that was using all the heap memory in that particular period of time, and going back to normal after we fix the problem with node.
• Something bad about the monitoring is that currently the instrumentation is not working for our version of MongoDB, that is because I cannot connect the web nodes with the database and add more information about the issue.

We have tested the performance of the hard disk from the linux side and from the mongo side and we didn’t achieve any clue about what it’s wrong. Our results were successful in both case.

For the time been, we have switched the storage type from MMAPv1 to WiredTiger, to see if there is a different behaviour, in theory it should not flush data from memory to disk in that way.

If you have any suggestion, we have posted the same information in the MongoDB user group. Or write a comment here :).

The post MongoDB IO performance appeared first on jenaiz.com - I think..

I was looking in Quora and founding some results. “What is best programming language for Artificial Intelligence projects?” is one of the most interesting, I was reading the answers from there. And the conclusion among the results is: Python (because it is fast to develop things and there are interesting libraries), C/C++ (because the speed and performance) or Java.

Taking a look to google, I found a tutorial written by Günter Neumann, from the German Research Center for Artificial Intelligence, entitled Programming Languages in Artificial Intelligence. In the tutorial, you can read why functional programming languages and symbolic languages are more useful for AI and then you find an introduction to Lisp and a small part for Prolog.

It is a simple introduction to Lisp, but I couldn’t avoid to remember µlisp (an small Lisp interpreter that I did, based in another book Build Your Own Lisp). I built a simple version of Lisp using C. In that point there were no standard libraries, you have to build them by yourself and I was wondering, if in that point you can start to create a language that it helps you to represent the world.

As always that was a crazy idea. Create a programming language that experts tell it is useful for artificial intelligence and build the standard libraries to represent part of the world that the system have to work with. As far as you go with the idea, you know that you cannot represent the complete real world with that approach, but… could you do a mix of implement part of the world with the programming language and part of the world based in the experience somehow? That was my thought, maybe there would be a way to do it.

By the way, my mind took me to start reading the new book of Deep Learning by Ian Goodfellow, Aaron Courville and Yoshua Bengio. In the introduction, there is a reference to Cyc (Lenat and Guha, 1989) and knowledge base.

A computer can reason about statements in these formal languages automatically using logical inference rules. This is known as the knowledge base approach to artificial intelligence. None of these projects has lead to a major success. One of the most famous such projects is Cyc (Lenat and Guha, 1989)  [extracted from the draft]

I am still thinking that it could work, because my approach is not to write every single rule of the world with the programming language, if not, to have some base using the language prepared for that specific problem like a DSL, but going further and without any limitation from the language itself. Either way, it is just an idea, I will continue reading the book from Yoshua Bengio, about deep learning it looks really promising and I will take a look to the review of the Lenat & Guha book, maybe I can figure out more.

The post A programming language for AI appeared first on jenaiz.com - I think..

Google was doing an interesting experiment, training a deep network with millions of parameters in thousands of CPUs. The goal was to train very large datasets without to limit the form of the model.

The paper describes the use of DistBelief, a framework created for distributed parallel computing applied to deep learning training. A collection of the features that the framework manage by itself are:

The framework automatically parallelises computation in each machine using all available core, and manages communication, synchronisation and data transfer between machines during both training and inference.

I couldn’t find too much information about it, only what it is written in the paper.

They have applied two algorithms: SGD (Stochastic Gradient Descent) and L-BFGS. These algorithms usually works well, but they doesn’t scale with very large data sets. That is because they introduce some modifications to them. The paper gives you more details about the optimisations in both algorithms that you can find interesting.

I was found really interesting the idea of distributed parallel computing working for very large datasets  in such algorithms.

You can read “Large Scale Distributed Deep Networks”, or if you are interested in the pdf version. Have fun!

The post Deep learning in a large scale distributed system appeared first on jenaiz.com - I think..

It is a good introduction to the topic. I enjoyed too much what was presented in the talk.

Lucene, Mahout, and Hadoop (only a little bit) sound really great for a talk about how to do text classifications.

The general idea behind the complete process to classify documents will follow the below steps:

HTML >> Apache Tika

Fulltext >> Lucene Analyzer

Tokenstream >> FeatureVectorEnconder

Vector >> Online Learner

Of course, Isabel was giving the advice of reusing the libraries that you have in your hands, taking an internal look at the algorithms used there, and improving them if you need them. As a first approach, it is really good for me to see how things work.

Mahout is a perfect library for machine learning, it was using map reduce to perfectly integrate with Hadoop (v1.0), although from April of 2014 they have decided to move forward:

The Mahout community decided to move its codebase onto modern data processing systems that offer a richer programming model and more efficient execution than Hadoop MapReduce. (You can read that in there web site).

At the end of the video, there is a recommendation to everyone to participate in the project: bug fixing, documentation, and reporting bugs. There are a lot of things to do in open-source projects always. If you are using the libraries there, I recommend you subscribe to the mailing lists if you are interested in the project.

I really recommend you to see the video if you have an interest in the field, she was giving a good talk about a good topic. You can take a look at the slides too.

The post Classifying documents using Apache Mahout appeared first on jenaiz.com - I think..

With these books, it is possible to learn general aspects about the topic and later go more in deep in the part that sounds more interesting.

Machine Learning

The “book” that everyone recommend as a good point to start, written by Tom M. Mitchell (professor in the Carnegie Mellon University).

This is an introduction book for the field. You don’t need to have previous knowledge in Machine Learning.

Some topics that you will find in the book: decision tree learning, artificial neural networks, bayesian learning, computational learning, genetic algorithms, reinforcement learning and more.

Pattern Recognition and Machine Learning (Information Science and Statistics)

The author is Christopher M. Bishop, a Distinguished Scientist at Microsoft Research Cambridge, where he leads the Machine Learning and Perception group

This book will give you a really good approach to the commonly used algorithms in Machine Learning.

Both books are theoretical and will give you a good introduction. Of course there so many books in the area, some of then more practical, some about statistical learning… But I think it is good to have a simple point to start.

I have started with Tom M. Mitchell’s book. I will give you my impression when I have finished it.

The post Two interesting books to start with Machine Learning appeared first on jenaiz.com - I think..

For me Scrum changed how things could be done better. Agile is what this book is about, but I, personally, feel that both are really connected. The names of the meetings or events are different but, how they are organize look similar.

The book is about how to execute your projects in a way that your customer feel more confident about the job that your are doing. It is not only about agile, it is about how to execute projects in a way that we can deal with changes and still have quality; having immediate feedback about the current status; how to be ready for production from the beginning.

Not all the customers are the same, not all the product owners are the same, not all the companies are the same, in conclusion: not all the XXX are the same.

I like the idea of Inception Desk. It is really good to have everyone in the team working in the big picture as an approach to start. As a mirror where everybody is looking how the project look for him and how the things are going to be. After that you can start and change the things later, if you need it.

In general the book is good for: to feel how it could be if you organize the project in a agile way; what are going to be the problems; how you could engage the customer/product owner; how the team should work; how testing and continous deployment should work; how transparent is going to be the status of the project; how you deal with the changes from the beginning… A lot of things together in a few pages :).

To know more, you should read it.

Thanks to Carlos Díez to lend me the book.

The post The agile samurai appeared first on jenaiz.com - I think..

One time ago, I used to write using tumblr, but it have not been updated a long time.

I needed to put all those interesting notes, comments, ideas, investigations together. I think the evolution of those ideas, the experiences, the articles read… every of those could be interesting to share & collect here.

The post Re-launch appeared first on jenaiz.com - I think..