A static variable is shared by all objects.

Since the static variable odes not change between objects. Static information is available even when you don't have an object.

When you design your own classes, you can also include static methods, also called class methods. Class methods are declared with the word static. They can be invoked using the class name, without the need to create instances/objects.

Why did I need to setVisible(true) after drawing?

//Instance Variables private String name = ""; private String sex = ""; private int max_hit_points = 0; private current_hit_points = 0;

//Constructors Character (String name, String sex, int max_hit_points, int current_hit_points){ this.name = name; this.sex = sex; this.max_hit_points = max_hit_points; this.current_hit_points = current_hit_points; } Character ( ){ this.name = "harvester"; this.sex = "male"; this.max_hit_points = 50; this.current_hit_points = 0; }

The name, sex, and max_hit_points given to the Character constructor won't override what's in the class by default, will it?

Class - Is the description or the blueprint of an object. Once a class is defined, we can create objects/instances of that class. A class name should be a noun, should begin with an uppercase letter, and each word within the name should also begin with an uppercase letter. Class names may not contain spaces.

Body of a class - The body of a class starts with an opening brace { and ends with a closing brace }. Member variables are declared after the opening brace, and outside of any methods. Class constructors and methods are coded within the opening brace { and closing brace }. Private variables and methods have a local scope ( visibility ), that extends from the opening brace of the class body to the closing brace. (see Encapsulation)

Constructor - A constructor is automatically called when an object is created. The constructor is were variables are initialized.

Getters - Getters or accessor methods are called to determine the value of a variable.

Setters - A setter or a modifier method is called to change the value of a variable.

Other Methods - We can include as many methods in the class as we like. Some useful methods are: toString(), equals(), clone(), draw(), etc.

Client Code - Refers to an application that uses one or more classes. The client can access the methods ot the class, but cannot directly access the data declared private in the class.

label.repaint();

you cannot access the JFrame from in here esp. using this

this.addMouseListener (new MouseAdapter() {

adding a mouse listener to THE WINDOW

The statements below placed in the main() method runs the GUI (Graphical User Interface) from an event dispatching-thread. GUIs should ve invoked from an event-dispatching thread to ensure that each event-handler finishes executing before the next one executes. Thorough coverage of this topic is beyond the scope of this lesson. However, the code shown is needed in every application that implements a Swing GUI.

A Swing timer (an instance of javax.swing.Timer) fires one or more action events after a specified delay. You can use Swing timers to perform a task repeatedly. For example, you might perform animation or update a component that displays progress toward a goal.

Swing timers are very easy to use. You create the timer, and you specify an action listener to be notified when the timer "goes off". The actionPerformed() method in this listener should contain the code for whatever task you need to be performed. To start the timer, call its start() method. In our example, the actionPerformed() method contains a call to the repaint() method. Basically this is how the paint() method is being called. We don't call paint() directly, we call repaint(), and the Java environment will run the paint() method.

It makes sense that we do "addActionListener(this)" because this object is an action listener (We have implemented it, and made it a child of ActionListener. Someone (who?) calls actionPerformed upon an action event )

g2.drawString("Hello world", 100, 100)

How does g2 know where to paint? Is it because it is in the JFrame object? And within the paint method?

this

this is whoever is drawing the object, in this case it is this, which is the panel itself

the panel itself is the object we are inside of, (the one who called paint)

• fill
• setStroke
• setPaint

so whenever paint is called, it is passed an argument g which we then modify.

so it paints based on what we have modified on the next run

super acts on the parent object.

So it is calling JFrame's (who is FirstFrame's parent-- FirstFrame inherits JFrame's properties (i.e: parent)) paint method.

frame.setSize

Calling the object's method

super

If your method overrides one of its superclass's methods, you can invoke the overridden method through the use of the keyword super.

Here, we are invoking the superclass's constructor

Extends makes it a child, inherit the class' methods and shit. You can override its shit if you want.

Implements allows you inherit the constants that are declared, and you can define these constants. The way that works is it provides a bunch of empty methods, and you fill in the gaps

Algorithm visualizations: sorting, binary search, graph search

Tutorial on using Rust to write an interpreter for an invented programming language.

Java Programming Language was developed by James Gosling, Chris Warth, Patrick Naughton, Mike Sheridan and Ed Frank at Sun Microsystems, Inc in the year 1991. At first Java Programming Language was named as Oak, later that it was renamed to Java in the year 1995.

Java Programming is a platform independent language. The Internet (World Wide Web) made Java programming more valuable. Since, Internet is connected to different types of systems which having different CPU's & environments, it must have the programs to run on any OS, CPU and Platform. Since, Java programming obtain platform independence and can able to run on any platform like Unix, Intel, Mac etc., it was widely used. Java language also protects two other major issues of Internet, they are security & portability.

Great Principles of Computing<br> Peter J. Denning, Craig H. Martell

This is a book about the whole of computing—its algorithms, architectures, and designs.

Denning and Martell divide the great principles of computing into six categories: communication, computation, coordination, recollection, evaluation, and design.

"Programmers have the largest impact when they are designers; otherwise, they are just coders for someone else's design."

How WSL (Windows Subsystem for Linux) enables native Linux ELF64 binaries to run under Windows.

Category Theory for Programmers<br> Haskell and C++, Bartosz Milewski

Transcrypt, a Python to JavaScript transpiler.

Using C11 or the earlier C99, which include some changes that make old C habits obsolete.

If you're reading this, do not forget the Content-Type. It is not on the initial example, but it is important. I don't understand why the author mentions it here but doesn't use it on the initial source.

Introduction to Computer Organization with x86-64 Assembly Language and GNU/Linux, Robert G. Plantz

Tutorial series on distributed systems.

Bitcoin and Cryptocurrency Technologies<br> https://www.coursera.org/course/bitcointech

http://software-carpentry.org/lessons/<br> Basic programming skills for scientific researchers.<br> SQL, and Python, R, or MATLAB.

http://www.datacarpentry.org/lessons/<br> Managing and analyzing data.

Tutorial on new features of JavaScript in ES6.

Notepad++, a free, open source text editor for Windows.

Collection of programming bit tricks with bitwise logical operators: & | ^ ~ << and >>

A thorough primer on C programming, specifically for the Texas Instruments TM4C123 or TM4C1294 microcontrollers. By Jonathan Valvano and Ramesh Yerraballi of UT Austin.

Recurse Center is starting a free one-to-one mentorship program for new programmers called RC Start. Those selected will get three 45-minute sessions with an RC alum, and access to a private forum and mailing list.

https://www.recurse.com/apply/start

Exercises for learning PostgreSQL.

Kotlin, a statically typed language that compiles to Java bytecode or JavaScript.

Online disassembler for many different CPUs that takes hexadecimal strings or several executable formats.

Swift GUI examples, and several links.

IBM has a Swift Sandbox.<br> Official guide: The Swift Programming Language

Kent C. Dodds shares some ideas about making open source projects friendly to new contributors. He starts with the obvious things: provide guides and good documentation. He suggests adding labels that make beginner-friendly issues easy to find. One idea that was new to me: Write the specification and tests for a new feature, then let someone else implement it.

How getting into open source has been awesome for me<br> What open source project should I contribute to?

Some people are porting Apple's Swift programming language to the Raspberry Pi. At the time of this post in December 2015, they had the compiler running on RPi 2 with Ubuntu Linux. They did not yet have the Foundation libraries, the Swift Package Manager, or a version for RPi 1, and it was not certain whether it would run on Raspbian Linux.

Peter Norvig's definition of deliberate practice, from "Teach Yourself to Program in 10 Years" http://norvig.com/21-days.html

In-browser JavaScript VM and debugger.<br> https://github.com/amasad/debugjs

Make Flow Visible from Bret Victor's Learnable Programming implemented with debug.js

repl.it - Web programming environment for several languages: C, C++, Java, C#, F#, Go, Python, Ruby, Lua, Scheme, PHP, Forth, APL

https://github.com/replit<br> https://twitter.com/amasad<br> https://twitter.com/HayaOdeh

Pamela Fox on careers that involve both coding and teaching.

Pronunciations for hexadecimal numbers:<br> 0xB3 "bibbity-three"<br> 0xF5 "fleventy-five"<br> 0xDB "dickety-bee"

BZARG is the work of Tim Babb, who lives in the San Francisco Bay Area, and is Lighting Optimization Lead for Pixar Animation Studios.

This blog focuses primarily on graphics, physics, programming, and probably some philosophy and fiction

Answer to question:

Why can't the Scala compiler give pattern matching warning for nonsealed classes/traits?

Elaboration:

one of the goals of Scala is separate compilation and deployment of independent modules, so the compiler simply cannot know whether or not a class is subclass in another module, because it never looks at more than one module.

Example: ??? When I try it, it seems to work, but this may be because everything I need is already loaded in the same compilation context. A subsequent answer seems to confirm this:

It can be done (at least for all classes known at compile time), it's just expensive. You'd completely destroy incremental compilation, because everything that contains a pattern match would effectively have to be recompiled every time any other file changed.

The Red programming language is based on Rebol (a Lisp-like interpreted language), but can compile binaries for several platforms. It is extremely lightweight. It covers the full range of programming tasks, from embedded systems to scripting. It's very young: they are working on a GUI library. http://www.red-lang.org/

Assuming that the type system provides for this. And assuming that it doesn't penalize you for doing this, for example by no longer allowing you to multiply both temperatures and masses by a plain scalar factor.

Again I think the problem is that type systems want to be universal, one size fits all. Even Haskell's type system (at least at the level of the '98 standard, I don't dare make a statement about the hundreds of extensions) is not sufficient to implement dimensional analysis. And yet, implementing dimensional analysis on its own is quite straightforward.

Dimensional analysis is indeed a simple protocol with a well-defined application domain. Type systems in programming languages want to be universal and in most cases compulsory for all of a program. Gradual typing is more flexible, but still assumes that a single type system is good for everything. Could we have type systems as libraries and use them as it seems appropriate?

This is a thoughtful, eloquent article. My main takeaway is that perfection is delusional, but good teamwork will overcome flaws and help everyone improve continually. All of these points are forms of feedback, or prerequisites to good feedback.

• treat coworkers with respect
• clear, open, honest communication
• 3 code reviews before release
• style guidelines
• pair programming
• unit tests
• manual testing
• user experience surveys
• user experience analytics

Mike Malone examines JavaScript's Math.random() in v8, argues that the algorithm used should be replaced, and suggests alternatives.

A good point, but unlike the author, I still feel that having a REPL is also important for distinction as a scripting language, as it facilitates rapid prototyping.

An interesting perspective, which is a bit like the dual of the Lisp mantra: "code is data".

Programming specific example: waiting for compile times, etc., is a killer.

Do you have what it takes? Signup on www.venturesity.com and unlock opportunities.

This is the hardest problem of writing and the ways it gets undermined can be so subtle. A roommate asking, "Is this your sock?" can wreck an afternoon.

Coding skills are a plus but not necessary. Accessibility!...

Perl's learning resources | http://www.perl.org/learn.html

Helpful concise, Python syntax doc

Full e-books on Perl

Fairly comprehensive guide to LISP Programming language- includes syntax

http://www.pythonlearn.com/ | A great resource for starting programmers looking to build knowledge and gain skills. Open Source Course

• Find a program that you greatly admire and read it.
• Takes note on the roles, inputs, and outputs of each major component.
• Take notes on how the components interact.
• Rewrite the program.
• Compare your code with the original.
• Note where you can improve and study accordingly.

Once you get the syntax and basic language idioms out of the way this is the real problem that faces us no matter what language we pick.

Understanding what you should (and should not) reason about in the language you are using is an important part of good programming; and a language that lets you reason (nee worry) about only the things you need to worry about is an important part of a good programming language.

"Ensuring Repeatability"

Taking this to heart / putting it on my wall.