Karol Majewski karol-majewski

Make it real

Ideas are cheap. Make a prototype, sketch a CLI session, draw a wireframe. Discuss around concrete examples, not hand-waving abstractions. Don't say you did something, provide a URL that proves it.

Ship it

Nothing is real until it's being used by a real user. This doesn't mean you make a prototype in the morning and blog about it in the evening. It means you find one person you believe your product will help and try to get them to use it.

Do it with style

Hi Zach :D

Modals are funny beasts, usually they are a design cop-out, but that's okay, designers have to make trade-offs too, give 'em a break.

First things first, I'm not sure there is such thing as a "simple" modal that is production ready. Certainly there have been times in my career I tossed out other people's "overly complex solutions" because I simply didn't understand the scope of the problem, and I have always loved it when people who have a branch of experience that I don't take the time

Complexity

As a decorator:

interface Record {}

@Complexity("n")
function getRecord(userId: number): Record {
 return db.getRecords().findWhere({userId}) // Error! Expected O(n) complexity, found O(log(n)) complexity

Code is clean if it can be understood easily – by everyone on the team. Clean code can be read and enhanced by a developer other than its original author. With understandability comes readability, changeability, extensibility and maintainability.

General rules

Follow standard conventions.
Keep it simple stupid. Simpler is always better. Reduce complexity as much as possible.
Boy scout rule. Leave the campground cleaner than you found it.
Always find root cause. Always look for the root cause of a problem.

	// # Mocha Guide to Testing
	// Objective is to explain describe(), it(), and before()/etc hooks

	// 1. `describe()` is merely for grouping, which you can nest as deep
	// 2. `it()` is a test case
	// 3. `before()`, `beforeEach()`, `after()`, `afterEach()` are hooks to run
	// before/after first/each it() or describe().
	//
	// Which means, `before()` is run before first it()/describe()

	#!/usr/bin/nodejs

	var Promise = require( 'promise' );

	/**
	*
	* @param {Array} list
	* @param {int} delay
	*/
	function recursivePromiseWithDelay( list, delay ) {

	const pkg = require('./package.json');
	const moment = require('moment');
	const localTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone
	const timeStamp = moment().format('LLLL');
	const banner = `
	Generated on ${timeStamp} - ${localTimeZone}
	Description: ${pkg.description}
	Package: ${pkg.name}
	Version: v${pkg.version}
	Contributors: ${pkg.contributors.map(function(contributor){ return contributor})}

	// see article with examples in JAVA here: https://dzone.com/articles/design-patterns-the-strategy-and-factory-patterns
	// example for educational purposes shownig close and mature syntax of modern TypeScript

	enum AccountTypes {CURRENT, SAVINGS, HIGH_ROLLER_MONEY_MARKET, STANDARD_MONEY_MARKET}

	////////////////////////////////////////
	/// the interface that is used by the strategy
	////////////////////////////////////////

	interface InterestCalculationStrategy {

	const map = fn => list => list.map(fn);
	const filter = fn => list => list.filter(fn);
	const compose = (...fns) => fns.reduce((f, g) => (...args) => f(g(...args)));
	const tail = list => list.slice(1);
	const fill = val => num => new Array(num).fill(val);

	const getFileContents = file => require('fs').readFileSync(file, { encoding: 'utf8' });

	const split = char => str => str.split(char);
	const join = char => list => list.join(char);