I’ve started watching the session videos of elixir conf. I really wanted to join the conference if possible, but it’s good that I can watch every session online.
Recent history of extended elixir capability, and coming future enhancements.
The recently added mix profile.fprof provides nice and easy interface for profiling. The fprof of erlang is somewhat cryptic and difficult to start using. The new ex_doc styling is getting nicer, along some other improvements.
Also, the coming future features like pipeline parallelism and GenRouter will be more extending the capabilities in parallel and distributed system, which sounds promising.
It might be one of the best talk with insightful ideas and encouraging statements. It introduces the power of elixir by comparing with historical progress in physics. It’s an insightful talk about how progress is being introduced, and how it relates to computer and programming architecture. The history shows always new ideas are coming and we need to keep thinking about what’s coming next.
Elixir has strong powers of
- Functional Programming : Immutability with data flow through actors
- Object Oriented : Independency in processes and message communication between actors
- Errors : Isolation with crash and recovery mechanism
which is enforced by the related ideas and technologies coming in this age. One remaining part is the
People to spread the idea to the world, which elixir is improving at the moment. Elixir is providing different
paradigm and it imposes certain difficulty, and sharing various types of experiences at different levels helps new-comers to improve themselves.
A well-written and well-covered guidance book for software engineers. Putting some distance from technical topics, it focuses on general productivity and career-developments useful for software engineers. Set of small chapters are providing good starting points for variety of topics. Also, essences are extracted from many good books (Rework, The Power of Habit, The Willpower Instinct, etc.) which guides you to further details.
Some of my notes are,
- Employment and Career
- One viewpoint is considering your employer as customer and think on what you’re offering to them. Also, market your offerings to the current employer or other possible future employers.
- In many cases hiring managers make decisions based on the social aspects of candidates rather than the technical aspect of the sill itself. Blogging and social media presence or referral from other engineer is important.
- Freelancing is one way to gain controllable career, but normally you need to earn twice as your salary as employee, considering the extra cost for your own business. Standard hourly rate in U.S. can be 50 dollars per hour and you may charge 100 dollars for example.
- It’s important to specialize. If you have specialized skill-set, it’s easier to sell. For example, the author has experience in building automated-testing framework, and selling a cost-benefit compared with building from scratch without specialized knowledge.
- Professionalism and Improving Skill
- Consistency is a key for professional work. Making a habit makes difference.
- Professional needs to identify when to say no. The client and software engineer can be like doctors and patients. The doctors don’t just do what patients asked to do. Analyze the issue and propose appropriate methods.
- Teaching and mentoring someone is a good method for learning which provides reorganizing process of your understandings. Don’t be too afraid to tell your knowledge confidently even when you’re not sure if it’s correct or not.
- Becoming accountable to yourself without relying on external trigger of motivation. Having a internal trigger provides more consistent and controllable behaviors.
- Breaking down tasks into smaller chunks makes it easier to start working on it, as represented as the structure of this book.
It’s a nice introduction presentation for the Rust.
Recently, I restarted exploring new programming languages. One is golang, but also the Rust is often compared with it in system programming area. They shares the concept of providing better C/C++, but they’re taking different approaches, and it’s interesting to see the differences between them.
Some description about ownership in official documentation.
The pointer ownership and borrowing concept is interesting idea for managing object life-cycle properly. Relatively simple restriction in grammar – which does not allow referencing same resource from different location – makes that possible at compile phase.
The functional programming languages provides a secure data sharing in data structure layer, and the Rust is providing at grammatical layer (variable assignments).
It’s a little old data, but the Rust seems one of the actively developed languages.
Just happened to find the presentation about live code updates on JVM, and was looking around it. I was knowing of the live reloading which some web frameworks provides, but didn’t know about the live updating of the codes while maintaining the state (variables, etc.).
The above presentation at twitter was implementing the dynamic class/method dispatching architecture by introducing additional layers into class hierarchy. It’s interesting approach, but introducing the layers seems to exposing the complexity, especially when states need to be updated or when reflections are involved. If it becomes open-source, it might be worth trying out.
- JRebel Java Plugin: Eclipse, IntelliJ, NetBeans | zeroturnaround.com
- Reloading Java Classes: HotSwap and JRebel — Behind the Scenes
As also noted in the question session in the presentation, the product JRebel seems to provide similar functionality as above. It doesn’t
The related article covers interesting topic too. The dynamically loading new classes can cause hidden chain in the class reference which fails the garbage collector to dispose the unused objects to be maintained in the heap.
Erlang is famous for live-code updating, and will be looking around the differences.
There’re many good applications which implements the pomodoro-style timer, but I couldn’t find good one which consistently works on laptop and mobile. Then, I came up to create one for my specific needs, and also for my study on Ruby on Rails application development.
It’s initial implementation yet, but I will be adding some more capability for fighting against my procrastination habits.
After watching one news about name servers, I just happened to gain certain interests on root name servers, and then I was looking around some documents. I think I knew the basic concepts, but there are many interesting topics around them which I didn’t know.
Normally, we don’t have to care about them much, but it might be one interesting topic to look into. It’s one of the critical component of the Internet anyway.
10 of the 13 root name servers are operated by United States organization, but the physical server location are widely distributed in the world. Also, each of the A to M has many server locations in the world. The following site has a nice map.
These root name servers are constantly getting high-load 24/7 (several tens of thousands per second). Decent TLD name servers should access only one in 48 hours, but not always the case.
The monthly average load of all root name servers in September 2007 is more than 118,000 queries per second (90,000 in December 2004) with regular peaks at several times the average which are handled gracefully.This is more than 10 billion (10^10) queries on average every day.
A: Indeed the expected load from well behaved root name server clients is much lower. For each TLD they should only need to query the root name servers about once every 48 hours. In practice the majority of the present load is coming from misconfigured or broken DNS clients.
A nice presentation about immutability from clojurescript creator. Immutable data structures are getting more attractions along with the popularity of functional programming language. The presentation covers related trie data structures and its advantages in performance along with new immutability-based platforms like Elm and React.
I used to be struggling on ruby’s clone method regarding performance and complexities in deep/shallow copy, but now I’m loving immutable data structures and tail-recursions while playing with elixir. When programming with ruby, I started to use hamster gem lately. It works nicely, but lack of tail-recursions sometimes painful.
I was taking the above coursera course – Learning How to Learn. It was a great course about how to learn effectively, which introduces learning methodologies based on how human brain works. There are various topics covered in the course, but which I started to apply right now is the Pomodoro Technique.
It’s a time management method which uses 25 minutes timer. Wikipedia describes as follows, and also there’re various web sites which covers this topic.
There are five basic steps to implementing the technique:
- Decide on the task to be done
- Set the pomodoro timer to n minutes (traditionally 25)
- Work on the task until the timer rings; record with an x
- Take a short break (3–5 minutes)
- After four pomodori, take a longer break (15–30 minutes)
I once tried to use more complex time-management system, but failed to keep using them. But this pretty-much simple process of Pomodoro works well. I regularly use todo list for managing daily work, but I sometimes face several issues, like
- Procrastinate large tasks by starting from small ones.
It’s easier to close smaller tasks and tends not to do the large or difficult work. Looking at task list, just completing a task drives the motivation, and then results in keep repeating on smaller tasks. Or, just avoid working on tasks and start playing games instead.
- Feel bad about incomplete tasks at the end of the day.
Over-time, tasks are piling up and it becomes difficult to complete all the tasks planned for the day. Not feeling well, and also cycle back to focusing on smaller and easier tasks.
Then, with pomodoro,
- Just start the initial work for large tasks.
The interesting factor of Pomodoro is structured on the “process” to take limited-and-focused time rather than focusing on “completing” tasks. It’s ok to split a large tasks into smaller ones, and also doesn’t have to feel much pressure on completing tasks on each pomodoro cycle.
- Feel OK seeing the number of completed Pomodoro along with the todo list.
It feels a little better to see the daily activities (with graph) based on the amount of time focused in addition to the number of completed tasks.
It’s working well to avoid procrastination. Also, it has similar agile development methodology. Rather than planning for the task completion beforehand, just start with small chunk and run as fast as you can. Then, We can adjust the direction between pomodoro or at the end of the day.
In a longer term, planning process is definitely important, but it can raise the threshold of taking actions. The fear of planning and completion requirement can cause the procrastination. This short period time of sprints and periodical retrospection would be a good approach to maintain the speed of the work.
Some watching notes of the above talk. Mostly about first-half of the talk. second-half is more conceptual and couldn’t understand enough.
[Around 8:00] Microservice concept affects the team structuring. Instead of having technology oriented team structure like UI, Server and DBA, cross technology members can build a team which responsible end-to-end relatively smaller service product.
[Around 8:30] The historical SOA (Service Oriented Architecture) is somewhat similar concept as Microservices, but SOA was focusing too much of smartness in the center of communications which leads to complex structures. Instead, Microservice tries to put the small set of smartness in each endpoint. What’s required is the powerful communication channel between endpoints.
[Around 12:00] Infrastructure automations are required for managing many services, with continuous integration or green/blue deployment technologies. Without this backbone, Microservice approach will fail.
[Around 14:30] What’s the difference between Microservice and SOA? SOA has too broad meaning, and Microservice concept can be considered as useful subset of SOA.
[Around 17:00] How big the Microservice should be? Many organizations are reluctant to answer this question straight. Actually, asking how many people are involved in a service results in wide variety of answers. It’s difficult to find one solution, but amazon’s 2 pizza team is a good notion.
There’re so many MOOCs (Massive open online course) lately, and I’ve completed around dozen of them during the past few years. They’re mostly pretty much well structured by the professors from the popular universities.
The above awesome-courses has a great set of courses mainly for computer science field. There’re so many vendors, but what I’m using are
They’re both nice. Then, my favorite courses I joined so far are,
Stanford University Cryptography I
- The course explains the basic and popular cryptography algorithms. Also, it has nice set of practice problems which includes cracking the encryption which has some flaw in implementation.
École Polytechnique Fédérale de Lausanne Functional Programming Principles in Scala
- The lecture from the creator of Scala. It covers the fundamental model of functional programming, and also good set of exercises to capitalize the power of Scala – pattern match, immutable data structure, higher-order functions, etc.
The MOOCs provides good opportunity for learning new field, through the combination of video lecture, exercise, and discussion forum. Even the field I thought I’m already familiar with, trying out a course provides new insights. I love it.