14mcs

That’s a very interesting question. Yes, I think it’s inevitable that as numbers go up, overall quality goes down. But the important thing to remember is that proportionally, the amount of great programmers is going to increase as well, which is a good thing.

What does concern me however, is that many prospective students are being pushed into the wrong major. It’s my opinion that someone who wants to write great software (and only that) should not be in a Computer Science major. Software Engineering is much more preferable to that end - but not every school has such an offering unfortunately. I was lucky that my school’s CS program is more like a 60/40 split between CS and SE.

There’s also the concern that class sizes are going to become a problem in the future. When I was in my first year, my introduction to programming class had roughly 100 students. This was already considered abnormally large - my year was one that had a large spike in CS majors compared to all of the years previously. I just asked the professor who teaches the first year courses, he says that class sizes are now in the ballpark of 200, which is absolutely crazy. He expressed to me that it’s becoming more and more difficult for him to run the lectures the way he has been, which is always unfortunate. Inevitably, class quality is going to drop with an increase in numbers, simply because it’s not feasible to give each student the same amount of individual attention when there’s twice as many students to take care of.

In a class on 2D vector graphics today, my Professor showed an example of simple svg animation using [Snap.svg](https://snapsvg.io). Immediately, the class noticed that the squares had a tiny jitter during each pass across the screen. Someone pointed it out, and the professor said that he wasn't too sure what was causing it. He encouraged the class to let him to know if anyone could figure out why.

Here's the snippet of code responsible for the squares:

<script src="./libs/snap/snap.svg-min.js"></script> <svg width="400" height="300" id="trans"> </svg> <script type="text/javascript"> window.onload = function(){ var s = Snap("#trans"); var outer = s.path("M0,0 L300,0 300,300 0,300 Z") ; var inner = s.path("M0,0 L300,0 300,300 0,300 Z") ; outer.attr({ fill: "pink", stroke: "lightblue", strokeWidth: 25 }); inner.attr({ fill: "lightblue", stroke: "pink", strokeWidth: 25 }); var trans = 0 ; function timerFunction() { trans = (trans+Math.PI*0.02)%(Math.PI*2) ; outer.transform("s0.5 t"+Math.cos(trans)*300) ; inner.transform("s0.75 t"+Math.sin(trans)*300) ; setTimeout(timerFunction, 30) ; } timerFunction() ; } </script>

Here's the link to where the snippet lives. There's an interactive box you can use to play with the code yourself.

These are the kinds of little puzzles that nerd-snipe me. I couldn't resist pulling out my laptop and poking at the code a little bit. After some fiddling, it was clear that the offending line was the transformation. I found out that if the Y argument to the translation directive was given explicitly like so:

// Creates a string like "s0.5 t300,0" outer.transform("s0.5 t"+Math.cos(trans)*300 + ", 0");

The jitter went away. This only made the rabbit hole even deeper, since "t300" should be entirely equivalent to "t300,0". It was clear at this point that whatever was causing the underlying behaviour exists within Snap.svg itself, and so I started digging.

The core of the problem is that Snap.svg does not support scientific notation in the transformation string. So a transform string such as "s0.5 t2e-11" isn't valid - however, it happily parses it anyways, and actually interprets it equivalent to "s0.5 t2,-11". In other words, the command parsing engine within Snap.svg is erroneously parsing the given exponent as the second argument.

Taking a step back, the reason why numbers in scientific notation are being passed in, is because Javscript chooses to represent very small (or large) numbers in scientific notation - even when concatenated as a string. In other words, "hello" + 0.00000000002 will construct the string "hello2e-11".

The reason why such a string is being constructed, is because the trigonometric calculations being done in our square code are returning very small numbers.

In the string construction:

"s0.5 t" + Math.sin(trans) * 300

Math.sin(trans) * 300 is evaluating to a very small number, like 2.2e-15.

At first, one might find that surprising - after all, trans is incrementing by Math.PI * 0.02 amounts every iteration, which is roughly an increase of ~6.6 each time. The reason here is because we apply a modulo of Math.PI * 2 in the calculation of trans. Since this number is irrational, we can see that there exists the chance that the calculation returns a very small number, which then results in a very small sine ratio.

An example would be if trans was 6.283185308, ever so slightly greater than Math.PI * 2 (6.283185307179586). Then trans % Math.PI * 2 evaluates to 1.640827917981369e-09 - which is very small indeed.

Having now understood what the real issue is, we can see that the fix of explicitly stating the second argument for transform is really only a fix by coincidence. The correct solution would be to eliminate the scientific notation from the string, which we can use the Number.toFixed() method to do (with limitations). In lieu of that, we can also round trans to avoid the jitter, at the cost of some fidelity.

The "real" fix would be to use repeated animation (native functionality within Snap.svg) instead of manually translating the squares.

I am learning python through Wikibooks and I am stuck on figuring out how the define statement works for the "test.py" example.

For def check_question(question_and_answer): statement, where are the question and answer variables pulling from? I would assume it would be from the list generated in def get_questions(): but there is no reference to it.

Secondly, given_answer=input(question) How does this statement work?

Thirdly, how does the "right" variable assign values in run_test(questions):

Lastly, what is run_test(get_questions()) doing? I know it calls in all the def statements together, but Im not sure how it does so.

So I'm going to correct some of your terminology first, because this will help you find the answers you need, once you know how to articulate them.

We call def check_question(question_and_answer): a function declaration, because it differs from a statement. To programmers, a statement is something that carries out an action - But the crucial difference here is that the function declaration is only creating the function. It's not being used, just merely stated to exist. You'll also hear people call them methods, procedures, or subroutines. They're all words used to describe the same overall concept, but with minor differences. It's OK for now just to assume all of these mean function.

We then call the statements that follow the function declaration, the function definition. It is called this because it specifies what happens when a function is invoked, which is just a fancy way of saying it is used. Sometimes, people also use "calling" to mean the same thing as invoked.

Next, question_and_answer inside the parentheses are called the parameters, or arguments to the function. These define the inputs to the function, which are given when the function is invoked. We also talk about the output of a function, which is what the return statement does for us. When this statement is executed, it "gives back" (outputs) whatever is returned, and then stops the execution of the function at that point.

Traditionally, we think about functions as being like a factory that accomplishes certain actions, like computing a value or showing something on the screen. You can visualize this essentially as a box that takes something in (input), performs some actions, and then gives back a result (output). We can think about the square root sqrt as a function - when we put in 4, we get back 2.

So in the case of the check_question function, question_and_answer is a parameter that is being given as a list (So it looks like ["Question 1", "Answer 1"]), and then all we're doing is breaking it up into pieces that are put into question and answer.

For given_answer=input(question), what we're doing is we're invoking the input function. What this function does is display the String (words) given as input, which is what is in the parentheses, and what it returns is whatever is typed in by the user.

When a function returns a value, you can think about that value as having "replaced" the original call to the function. So for example, if you wrote the statement sqrt(4) + 3, we can say that this is essentially the same thing as 2 + 3. Try to get in the habit of making mental substitutions like this, as it helps you understand what the program is doing.

I'm not entirely sure what you're trying to ask with the third question, so you may need to clarify that one.

For run_test(get_questions()), this is just invoking a function, where the input to run_test is the output of get_questions. If you do the mental substitution, we can rewrite this as:

my_questions = get_questions() run_test(my_questions)

and have it do the same thing. Let me know if you'd like any clarification on this stuff, and good luck!

"Am I fooling myself thinking that teaching myself C++ will eventually land me a junior position within the software industry?"

You're on a good track, but I would like to stress how important it is to learn the auxiliary skills that go beyond the language.

I notice you're already using git, which is a great first step - but the difference between knowing git commands and actually understanding git is a huge difference that is extremely valued in industry solely because of what a challenge team coordination is.

Also consider looking into developing strong documentation habits. Learn how to typeset and render your documentation with a system like Doxygen - it really separates the good developers from the great.

My last piece of advice would be to familiarize yourself with a distribution of Linux of your choosing. Getting some basic shell scripting skills under your belt will help you stand out. Ultimately, being a strong, well rounded developer means knowing all of your tools by feel. The programming language is just one tool in your box.

Reminder that I'm open to answering questions in Computer Science or Software Engineering. Whether its homework help, or if you're curious what working in academic research is like, feel free to ask.

I've started a new little project. Have you ever wanted a solid way to test the programming knowledge of someone you're trying to teach? Check this out.

What is RSA? What is asymmetric encryption?

To set the scene a little bit, lets talk about a different kind of encryption first. A traditional symmetric encryption model is comparable to that of a safe. A key is used to lock some data, which can then be unlocked by the same key. This form of encryption has existed for centuries, as known in famous forms such as the Caesar cipher, said to be used by Julius Caesar to securely pass messages back and forth from his troops. However, in the age of global communication, the fundamental flaw with symmetric encryption lies in the communication of the key. Before, it was simple to arrange a meeting with someone and confidentially exchange the key information. Of course, this is not feasible in the context of remote communication, where messages can be intercepted or captured by unintended persons1. A crucial development was the idea of an asymmetric encryption algorithm. The idea is two keys are created, which act as opposites. Labelled as keys A and B, what A locks can be unlocked by B, and vice versa. Typically, the keys are named the private and public keys, where the usage is as named: The private key is kept secret from anyone but the owner, and the public key is widely available and known. This solves the key transport problem, since the public key is intended to be distributed, and interception becomes a non-issue. Practically, asymmetric encryption has two main usages; one usage is communicating a confidential message to someone, and being confident that only they can read it. This is accomplished by locking the message using the recipients’ public key, where then the recipient can unlock the message using their private key. As an example, the message could be a credit card transaction on a shopping website. Using the public key belonging to the credit card company to encrypt the message, the shopping website can securely transmit your credit card credentials to the credit card company without worry that someone else can access it. The second usage is in authentication. If someone would like to send out a message and have it be certain that they are who they claim to be, they can encrypt their message using their private key. Then, when this is decrypted using their public key, it’s known without a doubt that the owner of the key-pair was the original author of the message. Some people like to sign their emails using such a method, as a way to verify their identity. The most widely used implementation of this idea is called the RSA cryptosystem, which is a set of algorithms that perform key generation, encryption, and decryption. As an important note, the mathematical basis on which RSA relies on ensures that attempts to crack the encryption scheme are intractable for any classical computer2. However, a complete quantum computer would be capable of breaking RSA in a reasonable amount of time. Shor's algorithm is a quantum algorithm that could be used to break RSA.

As a challenge for you, I encourage you to set up your own public/private key pair. Check out PGP for ways to do this.

Consider how you'd ensure that the key remains safe. You'd have to encrypt the message that sends the key. How would you accomplish that? Oh no! Recursion! ↩︎

I recently finished reading "The Pragmatic Programmer" (Hunt, Thomas).

If you're someone who feels like they can code proficiently, but you feel like you're having trouble writing good code, this is the book for you.

I wrote this while talking to one of the kids I mentor, and it turned into a pretty fun question.

QUESTION 1:

Write a guessing game in Java. Pick a random number between 1 to 100, and have the user guess what the answer is. If they guess wrong, output either "Too low" if their guess was smaller than the target, and "Too high" if their guess is greater than the target, and then let them try again. When they guess the correct number, congratulate them, and tell them how many guesses it took for them to get the right answer.

Example output:

Welcome to the magic guessing game! Take your guess: >34 Too low! >70 Too high! >50 Too low! >57 Correct! The number was: 57 You guessed 4 times.

QUESTION 2:

Write the "reverse" version of the guessing game. Tell the user to pick a number between 1-100 (in their head), and then the computer will try to guess at their number. Make several versions of this game:

a) The computer guesses sequentially. b) The computer guesses randomly (but does not repeat guesses).

The user responds "high", "low", or "correct" to the computer's guess. Output the number of guesses it took the computer to get the correct answer.

c) It is possible for the computer to always get the correct answer in 7 guesses or less. Can you write the algorithm to do this?

Why do I have to write <e extends comparable>> in both a class declaration, and the interface declaration? Will there ever be a time where I don't have to specify it for both? I thought that since the interface already has <e extends comparable>>, the class implementing the interface won't be needing it, since it already is implementing the interface.

On the topic of generics, there's a good rule of thumb you can follow: When you first declare the use of generics, you can read it as "we're going to use a type E, that hasn't been chosen yet and can be anything". When we go to use the class or interface that we declared, we have to pick what type E actually is. Remember that E is a name that you pick, and can be anything. So, this looks like:

public interface MyList<E> {}

Now here's the important distinction you have to keep clear in your head. When you go to use (or implement) the interface, it is at this time that you must choose what specific type is given for E. So, if we're making a class that only ever stores String objects, this might look like:

public class NameHolder implements MyList<String> {}

Why? Think back to the rule of thumb. Here, we're not declaring MyList, we're using it. Thus, we have to give it a concrete type. If the NameHolder class is also generic, you might propagate the generic type like this:

public class NameHolder<K> implements MyList<K> {}

But you have to keep in mind that this generic type is attached to the NameHolder and is being passed into MyList. This leads us to your question: If MyList is declared like this:

public interface MyList<E extends Comparable<E>> {}

(Which can be read as, "E is any type that is compatible with the Comparable interface"), Why is this not acceptable:

public class NameHolder<K> implements MyList<K> {}

And instead has to be:

public class NameHolder<K extends Comparable<K>> implements MyList<K> {}

What are invariants in programming and why are they important?

An invariant is something that always holds true. A loop invariant is probably the most common one you'll encounter.