<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Ostash.Dev</title>
    <link>https://ostash.dev/</link>
    <description>Recent content on Ostash.Dev</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <copyright>© Roman Ostash 2021</copyright>
    <lastBuildDate>Wed, 08 Sep 2021 00:10:16 -0900</lastBuildDate>
    
	<atom:link href="https://ostash.dev/index.xml" rel="self" type="application/rss+xml" />
    
    
    <item>
      <title>A concept of polymorphism in Clojure</title>
      <link>https://ostash.dev/posts/2021-09-08-clojure-polymorphism/</link>
      <pubDate>Wed, 08 Sep 2021 00:10:16 -0900</pubDate>
      
      <guid>https://ostash.dev/posts/2021-09-08-clojure-polymorphism/</guid>
      <description>Working with larger Clojure projects or libraries requires us to use some concepts that we all know from the Object Oriented Programming (OOP) world.</description>
    </item>
    
    <item>
      <title>Data validation in Clojure</title>
      <link>https://ostash.dev/posts/2021-08-22-data-validation-in-clojure/</link>
      <pubDate>Sun, 22 Aug 2021 00:09:16 -0900</pubDate>
      
      <guid>https://ostash.dev/posts/2021-08-22-data-validation-in-clojure/</guid>
      <description>As programmers we work with data every day. It has different forms: data may come from the database, an API endpoint or from the user input.</description>
    </item>
    
    <item>
      <title>Transient Data Structures in Clojure</title>
      <link>https://ostash.dev/posts/2021-07-08-transient-data-structures/</link>
      <pubDate>Thu, 08 Jul 2021 00:03:16 -0900</pubDate>
      
      <guid>https://ostash.dev/posts/2021-07-08-transient-data-structures/</guid>
      <description>Although in Clojure we strictly adhere to the idea of immutability we still have an option to work with mutable data structures.</description>
    </item>
    
    <item>
      <title>Pre and post conditions in Clojure</title>
      <link>https://ostash.dev/posts/2021-07-01-pre-post-conditions/</link>
      <pubDate>Thu, 01 Jul 2021 00:03:16 -0900</pubDate>
      
      <guid>https://ostash.dev/posts/2021-07-01-pre-post-conditions/</guid>
      <description>Today we will discuss a topic of pre and post assertions (conditions) in Clojure. The language gives programmers an option to set certain conditions we want to constrain our function with.</description>
    </item>
    
    <item>
      <title>Data notation in Clojure</title>
      <link>https://ostash.dev/posts/2021-06-24-edn-data-notation/</link>
      <pubDate>Wed, 23 Jun 2021 00:06:16 -0900</pubDate>
      
      <guid>https://ostash.dev/posts/2021-06-24-edn-data-notation/</guid>
      <description>Homoiconicity (code as a data structure) is one of the pillars of the Clojure language. It gives the extensibility and flexibility to the language.</description>
    </item>
    
    <item>
      <title>Clojure metadata</title>
      <link>https://ostash.dev/posts/2021-06-18-clojure-metadata/</link>
      <pubDate>Fri, 18 Jun 2021 00:06:16 -0900</pubDate>
      
      <guid>https://ostash.dev/posts/2021-06-18-clojure-metadata/</guid>
      <description>Conceptually metadata is an ability for the symbol or the collection to have some additional information for the Clojure compiler. It is implemented as a map data structure and is often used to convey the type information to the compiler, documentation and compilation warnings.</description>
    </item>
    
    <item>
      <title>Clojure atoms</title>
      <link>https://ostash.dev/posts/2021-06-02-clojure-atoms/</link>
      <pubDate>Wed, 02 Jun 2021 00:06:56 -0400</pubDate>
      
      <guid>https://ostash.dev/posts/2021-06-02-clojure-atoms/</guid>
      <description>All data structures in Clojure are immutable. Any changes we do will result in a new data structure leaving an original one untouched.</description>
    </item>
    
    <item>
      <title>Destructuring in Clojure</title>
      <link>https://ostash.dev/posts/2021-05-10-destructuring-in-clojure/</link>
      <pubDate>Mon, 10 May 2021 00:08:14 -0400</pubDate>
      
      <guid>https://ostash.dev/posts/2021-05-10-destructuring-in-clojure/</guid>
      <description>Destructuring in Clojure can be confusing for someone coming from the language where this technique is not implemented. Hopefully when you are done reading this article, destructuring will make sense and you will be implementing this method in your own coding projects.</description>
    </item>
    
    <item>
      <title>Working with ClojureScript at ease</title>
      <link>https://ostash.dev/posts/2021-04-12-working-with-clojure/</link>
      <pubDate>Mon, 12 Apr 2021 00:09:56 -0400</pubDate>
      
      <guid>https://ostash.dev/posts/2021-04-12-working-with-clojure/</guid>
      <description>Today we are going to talk about ClojureScript and review many useful functions and concepts you need to know when working with Clojure/JavaScript interoperability.</description>
    </item>
    
    <item>
      <title>Better learning with Clojure </title>
      <link>https://ostash.dev/posts/2021-02-20-better-learning/</link>
      <pubDate>Sat, 20 Feb 2021 00:04:56 -0400</pubDate>
      
      <guid>https://ostash.dev/posts/2021-02-20-better-learning/</guid>
      <description>Clojure comes with many useful functions that are a great learning resource for those who are just starting to explore the language.</description>
    </item>
    
    <item>
      <title>Clojure code comments</title>
      <link>https://ostash.dev/posts/2021-02-19-clojure-code-comments/</link>
      <pubDate>Fri, 19 Feb 2021 00:06:56 -0400</pubDate>
      
      <guid>https://ostash.dev/posts/2021-02-19-clojure-code-comments/</guid>
      <description>If we would like to comment out a line of the code we simply use a semicolon at the beginning. To comment out a block of the code we use hash underscore #_ (reader macro).</description>
    </item>
    
    <item>
      <title>Clojure namespaces</title>
      <link>https://ostash.dev/posts/2021-02-17-clojure-namespaces/</link>
      <pubDate>Wed, 17 Feb 2021 00:05:56 -0400</pubDate>
      
      <guid>https://ostash.dev/posts/2021-02-17-clojure-namespaces/</guid>
      <description>Let&amp;rsquo;s talk about namespaces today. Below is a structure of the core.clj file that is located in /src/app/ directory. Function ns sets the namespace.</description>
    </item>
    
    <item>
      <title>Bindings in Clojure</title>
      <link>https://ostash.dev/posts/2021-02-16-clojure-bindings/</link>
      <pubDate>Tue, 16 Feb 2021 14:42:56 -0400</pubDate>
      
      <guid>https://ostash.dev/posts/2021-02-16-clojure-bindings/</guid>
      <description>In Clojure we can bind a piece of the code/data to a var (variable). To declare a global var we use a def special form (similar to let keyword in JS world).</description>
    </item>
    
    <item>
      <title>Functions in Clojure</title>
      <link>https://ostash.dev/posts/2021-02-12-clojure-functions/</link>
      <pubDate>Fri, 12 Feb 2021 14:42:56 -0400</pubDate>
      
      <guid>https://ostash.dev/posts/2021-02-12-clojure-functions/</guid>
      <description>Functions in Clojure are data structures since the language follows code as a data structure principle (homoiconicity).
In Clojure those data structures are lists since it is a dialect of the LISP (LISt Processor) language, the second oldest language still in use today.</description>
    </item>
    
    <item>
      <title>Immutability</title>
      <link>https://ostash.dev/posts/2020-05-30-seventh-post/</link>
      <pubDate>Tue, 10 Nov 2020 14:42:56 -0400</pubDate>
      
      <guid>https://ostash.dev/posts/2020-05-30-seventh-post/</guid>
      <description>Mutable data structure can be changed after creation immutable cannot.
Paradoxically, when you need to mutate a data structure, is a time then you should use an immutable data structure because it allows a structured mutation.</description>
    </item>
    
    <item>
      <title>About</title>
      <link>https://ostash.dev/about/</link>
      <pubDate>Wed, 07 Oct 2020 14:45:56 -0400</pubDate>
      
      <guid>https://ostash.dev/about/</guid>
      <description>I&amp;rsquo;m Roman Ostash, a self-taught Software Developer. I love to code and to build applications. Thinking outside of the box, problem solving skills and perseverance in achieving my goals are helping me in my personal and professional development.</description>
    </item>
    
    <item>
      <title>A value mutability</title>
      <link>https://ostash.dev/posts/2020-05-25-sixth-post/</link>
      <pubDate>Sat, 03 Oct 2020 14:42:56 -0400</pubDate>
      
      <guid>https://ostash.dev/posts/2020-05-25-sixth-post/</guid>
      <description>Mutating a value. When you receive a data structure that is in its identity mutable, like an array or object, the best thing to do is to always assume that it is a read-only data structure and that you are not allowed to mutate it.</description>
    </item>
    
    <item>
      <title>Higher order functions</title>
      <link>https://ostash.dev/posts/2020-05-20-fifth-post/</link>
      <pubDate>Thu, 17 Sep 2020 14:42:56 -0400</pubDate>
      
      <guid>https://ostash.dev/posts/2020-05-20-fifth-post/</guid>
      <description>What is a higher order function(HOF)? If a function receives as its input one or more functions or/and returns the function we can called it HOF.</description>
    </item>
    
    <item>
      <title>Currying</title>
      <link>https://ostash.dev/posts/2020-05-17-forth-post/</link>
      <pubDate>Thu, 20 Aug 2020 14:42:56 -0400</pubDate>
      
      <guid>https://ostash.dev/posts/2020-05-17-forth-post/</guid>
      <description>Currying is an act of taking one function that receives more than one argument and refactoring it so it becomes HOF(a higher order function) that returns series of functions each accepting only one argument and only evaluating once we receive our final argument.</description>
    </item>
    
    <item>
      <title>Arity</title>
      <link>https://ostash.dev/posts/2020-05-15-third-post/</link>
      <pubDate>Wed, 08 Jul 2020 14:42:56 -0400</pubDate>
      
      <guid>https://ostash.dev/posts/2020-05-15-third-post/</guid>
      <description>Before we explain what arity is, let’s make a clear distinction between parameters and arguments in a function.
The parameter is a variable declared in the function expression.</description>
    </item>
    
    <item>
      <title>Functional purity</title>
      <link>https://ostash.dev/posts/2020-05-11-second-post/</link>
      <pubDate>Mon, 15 Jun 2020 14:42:56 -0400</pubDate>
      
      <guid>https://ostash.dev/posts/2020-05-11-second-post/</guid>
      <description>What is a function? For the function to be a function it has to return something, otherwise is a procedure. Function is a semantic relationship between input and computed output.</description>
    </item>
    
    <item>
      <title>The beginning</title>
      <link>https://ostash.dev/posts/2020-05-04-first-post/</link>
      <pubDate>Thu, 07 May 2020 14:42:56 -0400</pubDate>
      
      <guid>https://ostash.dev/posts/2020-05-04-first-post/</guid>
      <description>Like many of developers that were coding for the last few years, I was following mostly object oriented programming paradigm. Let’s not go into details on its specific implementation (hopefully the reader is familiar with it.</description>
    </item>
    
  </channel>
</rss>