bshlgrs

list of programming project ideas

Board games

Any two player board game is a good exercise for basic programming logic, and you can make it into a console application. Checkers, Connect-4, Othello, Poker, Go, whatever. Chess is somewhat harder than those other games.

Here are some ways to extend these projects:

• Add the ability to save and load games
• Add an AI

kgashok

import SStack as Stack exposing (..)
import Html exposing (..)

reverseString : String -> String
reverseString str =
  Stack.reverse str 


main : Html.Html
main =

kgashok

module Sample where

import Stack exposing (..)
import String
import Html exposing (..)

reverseString : String -> String
reverseString str =
  String.split "" str
    |> Stack.fromList

kgashok

-- https://packagecontrol.io/packages/sublime-github

import Html exposing (..)

main = 
  text "Hello, World!"

yang-wei

When receiving JSON data from other resources(server API etc), we need Json.Decode to convert the JSON values into Elm values. This gist let you quickly learn how to do that.

I like to follow working example code so this is how the boilerplate will look like:

import Graphics.Element exposing (Element, show)
import Task exposing (Task, andThen)
import Json.Decode exposing (Decoder, int, string, object3, (:=))

import Http

fasiha

[
  {
    "japanese": "ボブは魚が好きだ。",
    "english": "Bob likes fish.",
    "tags": [],
    "ve": [
      {
        "word": "ボブ",
        "lemma": "ボブ",
        "part_of_speech": "proper noun",

junjiah

from collections import namedtuple


# A reasonable large number to represent infinity.
INF = (1 << 31)
UNIT_LENGTH = 6
# Struct for edges.
Edge = namedtuple('Edge', ['src', 'dest'])

def calculate_shortest_distances(node_num, edges, src):

ohanhi

Learning FP the hard way: Experiences on the Elm language

by Ossi Hanhinen, @ohanhi

with the support of Futurice 💚.

Licensed under CC BY 4.0.

Editorial note

refo

 '/example/string/'.replace(/^\/+/g, '');
 
 // Should remove all leading slashes and return 'example/string/'
 

non

What is the appeal of dynamically-typed languages?

Kris Nuttycombe asks:

I genuinely wish I understood the appeal of unityped languages better. Can someone who really knows both well-typed and unityped explain?

I think the terms well-typed and unityped are a bit of question-begging here (you might as well say good-typed versus bad-typed), so instead I will say statically-typed and dynamically-typed.

I'm going to approach this article using Scala to stand-in for static typing and Python for dynamic typing. I feel like I am credibly proficient both languages: I don't currently write a lot of Python, but I still have affection for the language, and have probably written hundreds of thousands of lines of Python code over the years.