Luke Pawlik2016-10-07T18:51:56+00:00https://lukep91.github.io/Luke Pawliklukepawlik@gmail.comReact koans2016-10-07T00:00:00+00:00https://lukep91.github.io//2016/10/07/react-koans<p>A big part of my Junior Rails Developer course is learning front-end technologies. To be precise I am going to learn Javascript and React, which is a framework of choice for Arkency team.</p>
<p>My first task was to finish <a href="https://github.com/arkency/reactjs_koans">react-koans</a> made by Arkency to at least get some first look into it. It took me about two evenings to finish it and since I have never learned any JS framework before. Except for a little bit of Meteor around 1.5 years ago, but after such a long break I think it doesn’t count. Plus my Javascript is at very basic level. It took me some time to provide a proper solution to some of the exercises.</p>
<p>Overall react-koans served it purpose and I at least could make some assumptions how it works at least how I think it does some things. As for the koans itself. They were interesting and not overly complicated. But I do believe some of the descriptions could be clearer. And errors displayed by tests could be in some places more helpful at least for a beginner like me. But the whole experience with it was very positive and I do recommend you to check it out if you want to learn a little bit of React.</p>
<p>As for React and my first thoughts about it. First of all, everything I will write here is my opinion after just React koans and nothing else, to be honest, and probably is not accurate or simply completely wrong. But well those are my first feelings about it.</p>
<p>What I think is cool in React at least after finishing koans is that each component on a site is treated as a seperate object and all of it functions and states are described inside closed section.</p>
<p>The second thing I noticed and liked is that it seems to do just one thing and that its. It doesn’t try to be complete front-end frameworks from what I see and heard like ember or angular.</p>
<p>I am quite excited that in next weeks it will be a strong part of my course and I hope to share with you some cool things I will do with it. Also, I am going to read some books about Javascript soon. Two from Arkency and three others and I am going to let you know what I think about them in the future. You can check out my finished react-koans <a href="https://github.com/LukeP91/reactjs_koans">here</a>.</p>
<p>If you liked this post, you can
<a href="https://twitter.com/intent/tweet?url=https://lukep91.github.io//2016/10/07/react-koans/&text=React koans&via=luke_pawlik" target="_blank">
share it with your followers</a>
or
<a href="https://twitter.com/luke_pawlik">
follow me on Twitter</a>!</p>
Order or cart2016-09-03T00:00:00+00:00https://lukep91.github.io//2016/09/03/order-or-cart<p>Today I am going to write about another interesting part of my shopping cart project. On of interesting part was deciding how should I handle creating order.</p>
<p>Current user can add products to shopping cart and then create order. Making order doesn’t have any functionality except creating a new order and removing all products from a cart.</p>
<p>When I was trying to figure out the best possible way to tackle that problem I come up with three solutions. I will try to give you some pros and cons for each of them. At least how I see them.</p>
<h3 id="easy-way">“Easy way”</h3>
<p>The first way appeared to be the easiest solution that required minimal work on my side. In it, I assumed that since in my project order and cart don’t have any functional differences I could reuse Cart model and simply add a field that would mark it as ordered. It looked simple, fast what could go wrong, right?</p>
<p>Well, first of all, the assumption that nothing will change and functionality will stay the same for the whole project is let’s say brave. Even slight changes to order or cart would require serious effort to make it work. Almost each function would need to check if it was called for a cart or an order. Any changes to how they behave would cause serious headaches.</p>
<p>And the second problem as important. Order and Cart are completely two different things in reality so why should we treat them as the same thing in code. Cart is something that is “fluid” it can change any minute and order generally is constant. When made it doesn’t change barring any special cases.</p>
<h3 id="seemed-ok-way">“Seemed ok way”</h3>
<p>Next solution that I initially thought was the best to applied here was to make order and cart separate models but make both of them share cart_item model which would be renamed to just item order. It looked like it solves all the issues with first way. We separate order and cart, which now can have different functionalities and we don’t create an extra model to store the same information as between order and cart. Looks good for me. But it is not a good one and I will try to explain myself when describing the last solution.</p>
<h3 id="the-right-way">“The right way”</h3>
<p>You can probably figure out the right way now by yourself. It turns out the best way was to create separate models for order, cart, cart_item and order_item. Why separte order and cart I have explained above. Now we just need to figure out why order item is different than cart item.</p>
<p>First, they are completely two different contexts in our application and in real life and should be properly separated.</p>
<p>Second thing order item should store price, taxes for the product that were true at the time of making the order not now. In cart item, we store just reference to product and not actual values. So when anything about it changes like its price or tax it is reflected in the cart. But such thing should not happen in order. When we buy something we want to get an invoice for a price that was during making our order, not the price that is now. Also, any changes in taxes don’t affect orders that were made before that change.</p>
<p>Because of that and the fact that making one more model doesn’t add much complexity or requires a lot of extra time, I believe third solution is the best one.</p>
<p>If you liked this post, you can
<a href="https://twitter.com/intent/tweet?url=https://lukep91.github.io//2016/09/03/order-or-cart/&text=Order or cart&via=luke_pawlik" target="_blank">
share it with your followers</a>
or
<a href="https://twitter.com/luke_pawlik">
follow me on Twitter</a>!</p>
Path vs URL2016-09-01T00:00:00+00:00https://lukep91.github.io//2016/09/01/path-vs-url<p>Today’s post will be shorter than usual.</p>
<p>One day I started wondering what’s the difference between Rails some_route_path and some_route_url. Because at first, it looked like both returned the same address. After some research and help from Arkency, I learned that the difference is in fact quite significant.</p>
<p>Path helper provides a path that is relative to the root of a site. And should always be used if you provide a link inside your application. In that case, domain part is redundant.</p>
<p>URL, on the other hand, provides an absolute path, including protocol and server name. And should be used when you create a link for use outside your application. For example, when you send an email to confirm password absolute path is required.</p>
<p>If you liked this post, you can
<a href="https://twitter.com/intent/tweet?url=https://lukep91.github.io//2016/09/01/path-vs-url/&text=Path vs URL&via=luke_pawlik" target="_blank">
share it with your followers</a>
or
<a href="https://twitter.com/luke_pawlik">
follow me on Twitter</a>!</p>
Blogging for busy programmers2016-08-28T00:00:00+00:00https://lukep91.github.io//2016/08/28/blogging-for-busy-programmers<p>When I started my blog I was full of doubts. Will my posts be interesting? What if I make grammar or spelling mistakes? Or worse what if I write something that is untrue and wrong? How can I figure out what to write about? That is a lot of what-ifs, how’s and why’s that make you want to stop blogging and I was scared that I will suck at it. I forced myself to write the first post and you know what it was a lot of fun, to be honest.</p>
<p>And to help me with that <a href="https://arkency.com/">Arkency</a> gave me a book <a href="http://blog.arkency.com/blogging/">Blogging for busy programmers</a> by <a href="https://twitter.com/andrzejkrzywda">Andrzej Krzywda</a> as part of my course. I will try to give you an honest opinion about it and try to tell for who it might be useful.</p>
<p>So, what is that book about? In short about blogging. How to pick your audience. How to get ideas for posts. How to promote your blog. It also helps you deal with all those questions that I wrote about.</p>
<p>When I was reading it multiple ideas for blog posts were popping in my head. There is a part which says that you can turn some part of Slack conversation into a post about something. And guess what there was one already. And in next weeks and least couple more showed up.</p>
<p>There are some minor issues with this book. I personally don’t like the part in which blogging platforms are described because it’s honestly only part that can get out of date. And doesn’t bring much value in my opinion. But the rest of the book is worth reading.</p>
<p>So who should buy it? Honestly, anybody who would want to start a blog, but isn’t sure if he can do it and can afford it. It helped me for sure. You could say there is a lot of common knowledge about blogging. But sometimes what we need is someone to remind us about it.</p>
<p>If you liked this post, you can
<a href="https://twitter.com/intent/tweet?url=https://lukep91.github.io//2016/08/28/blogging-for-busy-programmers/&text=Blogging for busy programmers&via=luke_pawlik" target="_blank">
share it with your followers</a>
or
<a href="https://twitter.com/luke_pawlik">
follow me on Twitter</a>!</p>
Associations2016-08-27T00:00:00+00:00https://lukep91.github.io//2016/08/27/associations<p>An important topic in any application that tries to solve a problem are associations. Objects, items, things are connected in many ways with each other. And those connections are what today’s blog post will be about. It will show how to create and use basic associations in Rails.</p>
<p>As my next step in <a href="http://blog.arkency.com/junior-rails-developer/">Junior Rails Developer Course</a>, I was asked to create a simple app that will teach me how to use associations in Rails. In order to do that, I have created two models that represent employees in a company and various departments in it.</p>
<p>To create an association in Rails you need to do two things. Add proper method to both or one of the connected models. And then create a proper migration. In my app, I have decided that each Employee belongs to one of existing departments. Department has many employees, but also to make things more interesting each department belongs to the manager.</p>
<h3 id="belongsto">Belongs_to</h3>
<p>Belongs to is the simplest association which tells us that one object belongs to another one. For example, book belongs to an author or in our case each employee belongs to one of existing departments.</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">class</span> <span class="nc">Employee</span> <span class="o"><</span> <span class="no">ActiveRecord</span><span class="o">::</span><span class="no">Base</span>
<span class="n">belongs_to</span> <span class="ss">:department</span>
<span class="k">end</span></code></pre></figure>
<p>Another usage of belongs to was a bit trickier. I wanted to make each department to have one manager. But since I didn’t want to create a separate model for that because a manager is in fact on of department’s employees I needed to do it differently. Fortunately <em>belongs_to</em> method in Rails supports many additional options. One of which I used in that example. Rest of them you can check out in <a href="http://guides.rubyonrails.org/association_basics.html#belongs-to-association-reference">Rails Guides 4.1.2</a>. To make manager work I used <em>class_name</em>.</p>
<h4 id="classname">Class_name</h4>
<p>Class_name helps when model name can’t be figured out using association name. For example in our case association name was manager. But in our app manager is, in fact, an object of Employee class. Using <em>class_name</em> we can tell Rails that even though our association name is manager, the model that is actually used is called Employee.</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">class</span> <span class="nc">Department</span> <span class="o"><</span> <span class="no">ActiveRecord</span><span class="o">::</span><span class="no">Base</span>
<span class="n">belongs_to</span> <span class="ss">:manager</span><span class="p">,</span> <span class="ss">class_name: </span><span class="s2">"Employee"</span>
<span class="k">end</span></code></pre></figure>
<h3 id="hasmany">Has_many</h3>
<p>Another type of association used in my project is <em>has_many</em>. Which basically tells us that object of our class has a connection with many objects of another class. In that case, a department has many employees. Usage of that is fairly simple and you can see it in the code below.</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">class</span> <span class="nc">Department</span> <span class="o"><</span> <span class="no">ActiveRecord</span><span class="o">::</span><span class="no">Base</span>
<span class="n">has_many</span> <span class="ss">:employees</span>
<span class="k">end</span></code></pre></figure>
<h3 id="migrations">Migrations</h3>
<p>Last part that is required to make it work is to create proper migrations. That part of making proper associations is fairly simple. We create proper fields in the database for those tables that correspond to a model that has a <em>belongs_to</em> association in it. So in our case, we need to create the <em>department_id</em> field in employees table and <em>manager_id</em> in departments table.</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">class</span> <span class="nc">AddReferences</span> <span class="o"><</span> <span class="no">ActiveRecord</span><span class="o">::</span><span class="no">Migration</span>
<span class="k">def</span> <span class="nf">change</span>
<span class="n">change_table</span> <span class="ss">:departments</span> <span class="k">do</span> <span class="o">|</span><span class="n">t</span><span class="o">|</span>
<span class="n">t</span><span class="p">.</span><span class="nf">integer</span> <span class="ss">:manager_id</span><span class="p">,</span> <span class="ss">index: </span><span class="kp">true</span>
<span class="k">end</span>
<span class="n">change_table</span> <span class="ss">:employees</span> <span class="k">do</span> <span class="o">|</span><span class="n">t</span><span class="o">|</span>
<span class="n">t</span><span class="p">.</span><span class="nf">integer</span> <span class="ss">:department_id</span><span class="p">,</span> <span class="n">index</span><span class="ss">:true</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">end</span></code></pre></figure>
<p>There was one problem with a manager when I started to make my app work. I couldn’t figure out whether the department should belong to the manager or the other way. Fortunately, guys from <a href="https://arkency.com/">Arkency</a> helped me with that and explained that if I would put <em>belongs_to</em> in Employee I would need to create field <em>managed_department_id</em>. But since not all employees are managers many of them would have <em>nil</em> in it. It should be the department that has the <em>manger_id</em> field in it and because of that <em>belongs_to</em> should be in department model not in employee model.</p>
<p>You can check finished app on <a href="https://github.com/LukeP91/association_app">Github</a> and <a href="https://tranquil-fjord-78902.herokuapp.com/">Heroku</a>.</p>
<p>If you liked this post, you can
<a href="https://twitter.com/intent/tweet?url=https://lukep91.github.io//2016/08/27/associations/&text=Associations&via=luke_pawlik" target="_blank">
share it with your followers</a>
or
<a href="https://twitter.com/luke_pawlik">
follow me on Twitter</a>!</p>
<p>Cheers Luke!</p>
Hamming exercise2016-08-16T00:00:00+00:00https://lukep91.github.io//2016/08/16/hamming<p>When you try to become web developer there are obvious things you need to learn. HTML is the foundation of each website, so you learn that. Then you start to think that it would be nice if the website looked just a bit better and you learn CSS. Then you figure out you need some JS to make it more dynamic and some backend framework and in my case you start to learn Ruby on Rails. But, there is also one more important part, which shouldn’t be neglected if you aspire to become good programmer someday. We should learn how to write clean code and in the case of using objective oriented language how to write good OOP code.</p>
<p><a href="http://blog.arkency.com">Arkency</a> knows that and they also live by DDD. When I talked to <a href="https://twitter.com/andrzejkrzywda">Andrzej Krzywda</a> he explained that learning how to write nice, concise, idiomatic Ruby code will also be part of my course. And today’s blog post will be about my first tries to do that. Most of the tasks that I will be doing in the part can be found on <a href="http://exercism.io/">Exercism.io</a>. First, two tasks were fairly simple and I will not bother you with them. But the next one called Hamming exercise was where the real fun began. In that exercise, I was asked to create a method that returns a number of mutations between two DNA strands. For example, for DNAs “AGA” and “AGG” it should return 1. If you want to read more check out the <a href="http://exercism.io/exercises/ruby/hamming/readme">Readme</a>.</p>
<p>My first solution passed all the tests and used some methods that you can find in the Enumerable module. I think using those methods when writing Ruby makes code easier to read.</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="k">class</span> <span class="nc">Hamming</span>
<span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">compute</span><span class="p">(</span><span class="n">original_strand</span><span class="p">,</span> <span class="n">copied_strand</span><span class="p">)</span>
<span class="k">raise</span> <span class="no">ArgumentError</span> <span class="k">if</span> <span class="n">original_strand</span><span class="p">.</span><span class="nf">length</span> <span class="o">!=</span> <span class="n">copied_strand</span><span class="p">.</span><span class="nf">length</span>
<span class="n">original_strand</span> <span class="o">=</span> <span class="n">original_strand</span><span class="p">.</span><span class="nf">split</span><span class="p">(</span><span class="sr">//</span><span class="p">)</span>
<span class="n">copied_strand</span> <span class="o">=</span> <span class="n">copied_strand</span><span class="p">.</span><span class="nf">split</span><span class="p">(</span><span class="sr">//</span><span class="p">)</span>
<span class="n">original_strand</span><span class="p">.</span><span class="nf">keep_if</span><span class="p">.</span><span class="nf">with_index</span><span class="p">{</span> <span class="o">|</span><span class="n">x</span><span class="p">,</span> <span class="n">i</span><span class="o">|</span> <span class="n">x</span> <span class="o">!=</span> <span class="n">copied_strand</span><span class="p">[</span><span class="n">i</span><span class="p">]}.</span><span class="nf">count</span>
<span class="k">end</span>
<span class="k">end</span></code></pre></figure>
<p>Arkency members checked it and Andrzej commented on it telling me that this solution looks ok if we treat DNA strands as simple strings and nothing more. And that my solution doesn’t have any information about the domain. After couple of iterations I have created solution that looks like this:</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">class</span> <span class="nc">Hamming</span>
<span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">compute</span><span class="p">(</span><span class="n">original_strand</span><span class="p">,</span> <span class="n">copied_strand</span><span class="p">)</span>
<span class="k">raise</span> <span class="no">ArgumentError</span> <span class="k">if</span> <span class="n">original_strand</span><span class="p">.</span><span class="nf">length</span> <span class="o">!=</span> <span class="n">copied_strand</span><span class="p">.</span><span class="nf">length</span>
<span class="n">original_strand</span> <span class="o">=</span> <span class="no">DNA</span><span class="o">::</span><span class="no">Strand</span><span class="p">.</span><span class="nf">new</span><span class="p">(</span><span class="n">original_strand</span><span class="p">)</span>
<span class="n">copied_strand</span> <span class="o">=</span> <span class="no">DNA</span><span class="o">::</span><span class="no">Strand</span><span class="p">.</span><span class="nf">new</span><span class="p">(</span><span class="n">copied_strand</span><span class="p">)</span>
<span class="n">original_strand</span><span class="p">.</span><span class="nf">mutations</span><span class="p">(</span><span class="n">copied_strand</span><span class="p">).</span><span class="nf">count</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">module</span> <span class="nn">DNA</span>
<span class="k">class</span> <span class="nc">Strand</span>
<span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">strand</span><span class="p">)</span>
<span class="vi">@strand</span> <span class="o">=</span> <span class="n">strand</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">nucleoids</span>
<span class="vi">@strand</span><span class="p">.</span><span class="nf">split</span><span class="p">(</span><span class="sr">//</span><span class="p">).</span><span class="nf">map</span><span class="p">{</span> <span class="o">|</span><span class="n">nucleoid</span><span class="o">|</span> <span class="no">Nucleoid</span><span class="p">.</span><span class="nf">new</span><span class="p">(</span><span class="n">nucleoid</span><span class="p">)</span> <span class="p">}</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">mutations</span><span class="p">(</span><span class="n">copied_strand</span><span class="p">)</span>
<span class="n">nucleoids</span><span class="p">.</span><span class="nf">keep_if</span><span class="p">.</span><span class="nf">with_index</span><span class="p">{</span> <span class="o">|</span><span class="n">x</span><span class="p">,</span> <span class="n">i</span><span class="o">|</span> <span class="n">x</span><span class="p">.</span><span class="nf">nucleoid</span> <span class="o">!=</span> <span class="n">copied_strand</span><span class="p">.</span><span class="nf">nucleoids</span><span class="p">[</span><span class="n">i</span><span class="p">].</span><span class="nf">nucleoid</span> <span class="p">}</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">class</span> <span class="nc">Nucleoid</span>
<span class="kp">attr_reader</span> <span class="ss">:nucleoid</span>
<span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">nucleoid</span><span class="p">)</span>
<span class="vi">@nucleoid</span> <span class="o">=</span> <span class="n">nucleoid</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">end</span></code></pre></figure>
<p>It gives you much better understanding of Domain in which we are operating. It also makes it much easier to understand for someone who knows something about DNA.
There could be also one more thing extracted to separate module and that’s Hamming distance. Because as it turns out Hamming distance has nothing to do with DNA. In fact, it’s part of Information Theory and calculates differences between two strings.
During that task, I learned a lot about how we can represent parts of real worlds using OOP and how to not treat everything as strings, arrays, numbers, etc. because our world is much more complicated than that.
If you want to know more about it check out Arkency series in which Andrzej uses exactly the same exercise to explain basics of DDD.
<a href="https://www.youtube.com/watch?v=h5UF4LkGBSk">Part I</a>
<a href="https://www.youtube.com/watch?v=4j3IEUdgrv8">Part II</a></p>
<p>If you liked this post, you can
<a href="https://twitter.com/intent/tweet?url=https://lukep91.github.io//2016/08/16/hamming/&text=Hamming exercise&via=luke_pawlik" target="_blank">
share it with your followers</a>
or
<a href="https://twitter.com/luke_pawlik">
follow me on Twitter</a>!</p>
Post.new.valid?2016-08-06T00:00:00+00:00https://lukep91.github.io//2016/08/06/validations<p>Today I would like to share the next step in my Rails journey share with you all. Which is, as you can tell from the title, validation. Or, to be specific, making rails app check if a newly created object is valid in the context of its model and how validation works under the hood.</p>
<p>I was asked to create a simple application with just one model, and a controller. Next, I had to add some validations to it. I chose to make a simple “blog” app with only Post model. There was also one more restriction that <a href="https://twitter.com/andrzejkrzywda">Andrzej Krzywda</a> gave me. No scaffolds or generators except for the migration generator. That meant I had to create a model, a controller and all view files from scratch for all basic actions. As it turned out it was a great way to learn how it all works. In the end, I figured out that I could also create migrations without using a generator. From now on all my apps during Rails course will be created that way.</p>
<h3 id="model">Model</h3>
<p>I decided to split the whole process into more manageable chunks and the first one was easy. Create a model with some simple validations. At the beginning, I decided what fields should it have and how they should be validated. So, a blog post should at least have a title, which I thought should not only be present - it doesn’t make sense to create posts without a title, right? But also, it should have length constraints. I thought a way too short title doesn’t make any sense and one that is too long, on the other hand, would make it difficult to understand what the post is about. Next thing that is even more important is the actual content of the post. What’s the point of creating empty posts? And the last thing which I thought should be optional was the author.</p>
<pre><code class="language-language-ruby">class Post < ActiveRecord::Base
validates :title, presence: true, length: { in: 2..50 }
validates :content, presence: true
end
</code></pre>
<p>Code for that model is very simple, but the purpose of that task was to learn how validation works under the hood and not how to make the most bulletproof model. Ok, the first thing I did learn was that each model inherits from the ActiveRecord::Base class. That class includes multiple modules and one of them is the module responsible for validations. One of the methods in that module is validation, which in very simple words runs all validations for given fields and checks if any errors were found. Since I am at the beginning of my learning process that was all that I needed to know for now.</p>
<h3 id="controller">Controller</h3>
<pre><code class="language-language-ruby">def create
@post = Post.new(post_params)
if @post.save
redirect_to @post
else
render 'new'
end
end
</code></pre>
<p>Next thing on the to-do list was to create controller that was responsible for all CRUD operations on my posts. From a validation perspective, the most important part was the code that you could find in the create and update methods. To be even more specific the <em>save</em> and <em>update_attributes</em> methods. In very simple words, that code works like this. First, it checks if an object that called it is valid, if that assertion is true, it creates an SQL query that inserts it to the database. If the object is not valid it rerenders a proper template with errors listed and all invalid fields marked.</p>
<h3 id="view">View</h3>
<pre><code class="language-language-html"><% if @post.errors.any? %>
<div id="error_explanation">
<h2><%= pluralize( @post.errors.count, "error") %> need to be fixed before saving that post.</h2>
<ul>
<% @post.errors.full_messages.each do |message| %>
<li><%= message %></li>
<% end %>
</ul>
</div>
<% end %>
</code></pre>
<p>Ok, that was last part that needed to be done. The actual views with proper error displaying. To make that happen first we need to check if our object has any errors using <em>@object.erros.any?</em> and later, thanks to a cool method pluralize, return the number of errors with some fancy text. Finally, we have to iterate over the collection of all error messages for our object and display them in a form of a list.</p>
<p>You can find finished app on <a href="https://damp-anchorage-94507.herokuapp.com/posts">Heroku</a> and <a href="https://github.com/LukeP91/validation_app">Github</a>.</p>
<p>If you liked this post, you can
<a href="https://twitter.com/intent/tweet?url=https://lukep91.github.io//2016/08/06/validations/&text=Post.new.valid?&via=luke_pawlik" target="_blank">
share it with your followers</a>
or
<a href="https://twitter.com/luke_pawlik">
follow me on Twitter</a>!</p>
Hello, World!2016-08-05T00:00:00+00:00https://lukep91.github.io//2016/08/05/hello<p>Hello, World!
Two of the most iconic words in programming world in my opinion. Those are the first two things most of us see at the very beginning of our journey to become developers. We start by learning how can we make that simple string print either on a website or console window.</p>
<p>After that way too long introduction that probably bored to death most of you I think it’s time to introduce myself and explain why am I blogging in the first place.</p>
<p>So my name is Luke and I am currently employed in one of biggest Polish IT companies as Software Quality Assurance Engineer, but that blog will be about something else. It will serve as a place for my story of becoming Junior Rails Developer. And maybe someday you can find here some more advanced stuff and maybe some general IT posts.</p>
<p>To do that I thought it would be cool to have some help from more experienced guys. And as most of you probably know since you got here thanks to <a href="https://twitter.com/arkency">@arkency</a> retweet I am brand new padawan taking part in theirs <a href="http://blog.arkency.com/junior-rails-developer/">Junior Rails Developer Course</a>.</p>
<p>I started that post with ‘Hello, World!’ and to make nice closure I will end it with one.
Ladies and Gentlemen my first Rails app <a href="https://sheltered-springs-23597.herokuapp.com/">Hello, World!</a>. Github: <a href="https://github.com/LukeP91/hello_world">hello_world</a> .</p>
<p>Cheers
Luke</p>
<p>If you liked this post, you can
<a href="https://twitter.com/intent/tweet?url=https://lukep91.github.io//2016/08/05/hello/&text=Hello, World!&via=luke_pawlik" target="_blank">
share it with your followers</a>
or
<a href="https://twitter.com/luke_pawlik">
follow me on Twitter</a>!</p>