Forem: Mayemene Fomene Jean Vladimir

Scope

Mayemene Fomene Jean Vladimir — Thu, 09 Aug 2018 15:19:35 +0000

What is the difference between lexical scoping and dynamic scoping?

Make A Recursive Anonymous Factorial Function In Python.

Mayemene Fomene Jean Vladimir — Wed, 04 Jul 2018 08:54:09 +0000

I'm currently taking Structure and Interpretation of computer programs from the University of Berkeley. Here is a nice question from one of the homeworks. You might want to try your hands at it.

Q6: Anonymous factorial
The recursive factorial function can be written as a single expression by using a conditional expression.

>>> fact = lambda n: 1 if n == 1 else mul(n, fact(sub(n, 1)))
>>> fact(5)
120

However, this implementation relies on the fact (no pun intended) that fact has a name, to which we refer in the body of fact. To write a recursive function, we have always given it a name using a def or assignment statement so that we can refer to the function within its own body. In this question, your job is to define fact recursively without giving it a name!

Write an expression that computes n factorial using only call expressions, conditional expressions, and lambda expressions (no assignment or def statements). Note in particular that you are not allowed to use make_anonymous_factorial in your return expression. The sub and mul functions from the operator module are the only built-in functions required to solve this problem:

from operator import sub, mul

def make_anonymous_factorial():
"""Return the value of an expression that computes factorial.

>>> make_anonymous_factorial()(5)
120
>>> from construct_check import check
>>> check(HW_SOURCE_FILE, 'make_anonymous_factorial', ['Assign', 'AugAssign', 'FunctionDef', 'Recursion'])
True
"""
return 'YOUR_EXPRESSION_HERE'

Floating Point Imprecision

Mayemene Fomene Jean Vladimir — Wed, 13 Jun 2018 04:59:02 +0000

What is Floating point imprecision?

These two expressions in python are suppose to produce the same result. But why don't they do that?

>>> 7 / 3 * 3
7.0

>>> 1 / 3 * 7 * 3
6.999999999999999

When should you be careful about floating point imprecision?

How To Design Computer Programs

Mayemene Fomene Jean Vladimir — Sun, 03 Jun 2018 22:12:12 +0000

Why Think About Program Design Before Coding?

Give me six hours to chop down a tree and I will spend the first four sharpening the axe, said Abraham Lincoln. This
statement also applies to software development. The truth is, in order to develop great software you have to put in a lot of thought
around the design and interactions of the software components. Why spend time on program design? If you put in time to think about
your program design you will spend less time coding. Following Abraham Lincoln's quote, you will spend 33.3% of your time coding. This is because after program design you know all the classes and methods which you have to code and how they will change the state (data) of your program. It will help you think about your program as a group of modules interacting with each other thereby making your program modular. Modularizing your program will ease task assignment during development. It will help you write better code as you will have to think about program decomposition and step wise refinement. All in all, thinking about program design before coding will make you a better software engineer and programmer.

Why Use Tic-Tac-Toe As Our Case Study?

Tic-Tac-Toe is a paper-and-pencil game for two players, X and O, who take turns marking the spaces in a 3×3 grid. The player who succeeds in placing three of their marks in a horizontal, vertical, or diagonal row wins the game. The following example game is won by the first player, X (En.wikipedia.org, 2018):

Players soon discover that the best play from both parties leads to a draw. Hence, tic-tac-toe is most often played by young children (En.wikipedia.org, 2018).
I choose Tic-Tac-Toe as our case study because it is relatively easy to program and programming it will give me the chance to talk
about some key software engineering techniques. You can find the code at the following link:
Fork me on Github

Strategies For Designing Better Programs

Decomposition

As computer scientists, we know that to solve a big problem we need to break it into smaller problems and solve these smaller problems. In software design we do exactly the same thing. To develop the Tic-Tac-Toe game, I decomposed it into the following pieces:

Initialize the players - Get players' names, assign them drawing symbols and ids.
Initialize the game grid - Draw the grid for Tic-Tac-Toe and set the initial turns for Players.
Wait for a player to play their turn
If a player has played, Check for a win
If there is a win, ask the players whether they want to continue playing.
If they want to continue playing, reset the game grid and reset players' turns(go back to 2), otherwise declare the winner of the game and exit the program.
If there is no win, alternate turns and go back to 3.

This was my initial strategy for developing this software. I had to change this strategy when I started writing the code and I realized that most of the players' actions in the game were going to be MouseClick events and I will have to handle them by implementing event listeners.

Programming Paradigm

When working on a software project, it is advised to pick a programming paradigm to use while writing your code. For Tic-Tac-Toe, I'm using an Object Oriented Programming Paradigm. That means, I designed the whole program around classes and interfaces.

TicTacToe class - This class contains the main method of our program.
GameBoard class - This class implements our gameboard and handling all the interactions on it.
Player class - This class represents a player in the game and also stores that player's attributes.

Aside from these classes, there is a GameConstants interface shared by these classes. This interface specifies all the constants
needed for the game.

Good Names and Method Length

When programing make sure your classes' names, methods' names, variables' and constants' names reflect what the class represents or what they do. Good class, method, variable and constant names will reduce the amount of commenting that you have to do. All my class names reflect what each of these classes either do or stand for.
- Example of Good Method names - initGrid(initializes the tic-tac-toe game grid), checkForWin(after a player plays check whether the player won), drawCircle(draws circles on a grid cell), drawCross(draws cross on a grid cell) and recordScore(records the score for a particular player).
- Example of Good Variable names - scoreBoard(an array that keeps track of the players' scores), boardState(an array of Grid cells that keeps track of the state of the board)
- Example of Good Constant names - NUM_OF_PLAYERS(represents the number of players in the game), NUM_GRID_ROWS(number of rows on the game grid), NUM_GRID_COLUMNS(number of columns on the game grid)

Version control

Whenever you are working on a project, make sure you start by initializing a repository using Git or any other version control tool of your choice. Whenever you add a new functionality to your code, make sure you stage and commit it these changes. Stage and commit very often, don't wait until you have achieved a major milestone before you stage and commit the changes.

Code Review

Ask a peer to review your code and tell you how you can make it better. If you want to review my code, send me a request at the email below:

Contacts:

Follow me on Twitter

Fork me on Github

Email Me: vladimirfomene@gmail.com

How To Setup Your Blog

Mayemene Fomene Jean Vladimir — Tue, 15 May 2018 19:54:03 +0000

Why blog?

Blogging is way for you to share your ideas on topics that you are interested in. These topics do not need to be technical though in our case it is going to be.
According to Sifus (masters or teachers), the best way to learn is to teach, therefore many people write to learn and teach at the same time. Among other things, blogging will help you refine your writing skills and share your work with a larger technical audience like folks on HackerNews, dev.to and other community sites. You will learn how to effectively communicate your amazing ideas with people of all technical backgrounds. As a blogger, you are also building a track record for yourself which can land you amazing opportunities like talking at conferences and job opportunities. If you do a great job, you will build an audience you can reach out to when you need support.

Why Jekyll?

Jekyll is a blogging framework written in Ruby. It is very simple and easy to setup. You can setup a blog on the web in a less than a day. Yes, you heard me, less than a day. Furthermore, you can easily host your Jekyll blog on Github Pages with a single git push for free. Hakuna Matata(No worries), if you don't know how, I will show you. In Jekyll, you can write your blog post in a textfile or a markdown file and Jekyll will automatically generate your html pages using a markdown builder or textfile builder. This allows you to quickly make updates to your blog and easily include your code snippets, images and videos in your post. Jekyll also comes with some pre-built themes which you can use for styling and laying out your site.

How to use Jekyll?

1. Get Jekyll On Your Computer

Go to the Jekyll website and download the version of Jekyll that corresponds to your operating system. I will explain the process for Windows OS since I use Windows.
Go to the Git website and download Git if you do not already have it. Install Git, without changing any of the default configurations.
Download Ruby using the Ruby installer, on the Jekyll installation page. Then, open the command prompt and run gem install jekyll bundler to install Jekyll and Bundler. Bundler is a library downloader for Ruby.
Check if Jekyll was installed properly by running the following command in your command prompt:
jekyll -v. You should see the following result:

Go to a directory of your choice and type jekyll new username.github.io where username is your Github username like vladimirfomene in my case. This command will create a directory for your blog with some skeleton files and directories in it. Jekyll creates every new blog with its default theme(minima).
Then move to the username.github.io directory and list the content. You should see the following folder and files:

The 404.html page will appear when someone navigates to a page that was not found in your blog directory. Jekyll generates a .gitignore file which has a listing of all the files and directories Git should ignore when doing version control. This file contains a directory called _site on it first line. This directory will be generated when you will run bundle exec jekyll serve in your command prompt to launch the Jekyll server so as to see your site in a browser. This directory contains the generated version (all your markdown or textfile have been converted to webpages) of the blog that will be served to your browser. The Gemfile in the directory is used by bundler to manage the libraries needed by Jekyll. The folder also contains an about.md and index.md file which are created by Jekyll for you and will be converted to html pages upon serving your blog. Index.md will become index.html(homepage), about.md will become about.html and will represent your about page. The _config.yml file contains configuration for your blog. Like the title of the blog. The url, markdown parser, email and the theme used by your blog. Below is a section of the config.yml of this blog:

title: Code Tiles
email: vladimirfomene@gmail.com
description: >- # this means to ignore newlines until "baseurl:"
  Vladimir Fomene's learnings, repository of ideas, teachings and talks.
baseurl: "" # the subpath of your site, e.g. /blog
url: "" # the base hostname & protocol for your site, e.g. http://example.com
twitter_username: vladimirfomene
github_username:  vladimirfomene

# Build settings
markdown: kramdown
theme: minima
plugins:
  - jekyll-feed

After running bundle exec jekyll serve, you should see the following:

This indicates that your Jekyll server is running and serving your blog at 127.0.0.1:4000. You can now type 127.0.0.1:4000 in a browser to visit your blog. You should see the following:

Writing Your First Post

In your blog directory, create a folder named _posts. All your posts will live in this directory and they should follow the following pattern: YYYY-MM-DD-name-of-post.markdown, where y is for year, M for month and D for day. A typical post should look like the following:

---
layout: post
title:  "Welcome to Jekyll!"
date:   2015-11-17 16:16:01 -0600
categories: jekyll update
---

You’ll find this post in your `_posts` directory. Go ahead and edit it and re-build the site to see your changes. You can rebuild the site in many different ways, but the most common way is to run `bundle exec jekyll serve`, which launches a web server and auto-regenerates your site when a file is updated.

The section at the top of the post, in between the dotted lines gives Jekyll relevant information about the page which will be used during page rendering. In our case, the layout to use, the title of the page, the date and the categories under which the post falls. You can list all your posts in any page using the following syntax:

<ul>
  {% for post in site.posts %}
    <li>
      <a href="{{ post.url }}">{{ post.title }}</a>
    </li>
  {% endfor %}
</ul>

Host on Github Pages

To publish your blog on Github pages, you need to initialize your blog directory as a local Git repository by running git init. Then, stage your directory content with git add . and commit with git commit -m "commit message". Then go to your Github profile and create a repository called username.github.io where username represents your Githubusername.

Then, connect your local repository to your remote repository by entering the following command in the command prompt: git remote add origin remote-repository-name.git. Push your local repository content to your remote repository by running the following commmand: git push -u origin master. You can now access your blog online by visiting username.github.io.

That's it for now. Click to learn more about Jekyll.

Contacts:

Follow me on Twitter

Fork me on Github

Email Me: vladimirfomene@gmail.com