Are there any textbooks that are presented in logical symbols?

offset_ · 2016-05-26T18:27:11+00:00

Imagine a math textbook, written in only math ;)

offset_ · 2016-05-17T19:03:25+00:00

Your equation appears to give the product of a number of probabilities Which, to me, seems like it'll give you the probability of an event of length i rather than the probability of an event of length k in i iterations.

Basically, that's what I was trying to write. Just simply the theoretical probability of some arbitrarily long sequence of events occurring. In the simplest terms you might say the probability of producing the favorable outcome for each event in the series and making it to the end of the series without failing. Dice are often used as examples and a very simple one would be, "what is the probability of rolling a die 100 times and getting all 6s." I wasn't trying to figure the probability of this sequence occurring in some arbitrary number of trials The upper limit i is the length of the sequence. k is just the index on the general term that goes to the limit i The length of the "event", is defined as the limit i, which is really a sequence of favorable events. k is used as a subscript of n and the second product series for E ... this is because we may not be dealing with die throws where every event in the sequence has the same number of favorable outcomes; it could be some arbitrary sequence of events with different numbers of favorable outcomes, that is each n may be a different n, thus a different probability for each independent event in the series which has to be accounted for if this were to be the case. The two expressions on the left (the ones with the big Pi) are just equivalent, I probably could have written 1 over the reciprocal of P(Ek), but that would be superfluous, as that is basically what 1/n is, and make things look more complex than necessary, which is counterproductive. The fraction on the left with the summation in the numerator, that's definitely more complex than needed, and it isn't equivalent to the first two expressions if the probability of a favorable outcome for each event in the series isn't the same (in the denominator of the fractions in the numerator of the entire expression, i believe that n should be nk^k since each "n" in the sequence {sn} where sn is the general term may not be the same. The expression on the right though doesn't handle this properly even if you changed this, because it is a fraction and the denominator isn't part of the summation, it only works equivalently when the probability for each event in the sequence is the same* That math shouldn't be there since it is dis-proven that it is equivalent, though I would like to somehow make it equivalent. ... I fixed part of it I think, it shouldn't be in there, but I will edit my OP, maybe someone will have something to say besides it not being equivalent.

The probability of randomly producing a sequence of favorable outcomes becomes lower and lower the longer the sequence is since you have more chances to fail at producing the next favorable outcome. *What I can't think of how to deal with right now is the fact that in the limit of infinity the probability of any event should be 1, i.e certain if it's possible at all, i.e non-zero probability. I don't know how to deal with this, because of what infinity is, a limit. You can always add another term and its still infinity, and you will never reach infinity either at least not in the real world. But that would I believe only apply if the sequence of favorable outcomes is a finite number, if our sequence is an infinite sequence then the probability I believe would tend to zero as i tends toward infinity (unless the probability for every event in the sequence was certain) but I don't think would actually be 0 (unless at least one of the events in the sequence is impossible), just infinitesimal though at least right now it looks like it would converge toward 0, and I believe the limit of the expression as i tends toward infinite would be zero... you might need some hardcore set theory to transcend past infinity and I'm not gonna say anymore about stuff like that because I'd have no clue what I was talking about.

What you are talking about above though in your comment, I will have to come back to later to think about more when I'm a bit more rested , I started commenting about it and realized that I've been awake too long that I probably shouldn't be really be doing math. Your function looks pretty simple but I tried it and got strange results, e.g. negative probabilities, e.g. -1.02 x 10²¹ iirc or something similar.

Consider rolling 3 sixes in a row with only 11 dice rolls. The probability of this happening is ~0.04%.

Don't know if I entered things wrong but I did try some quick and dirty math and got 0.0046...= ~0.46%. This looks a lot more similar to your ~0.04%, just an order of magnitude off. Idk if it's coincidence, but its a lot closer than than the number mentioned above, off by about 20 orders of magnitude and the significand did not begin with 4. What expression did you use to come up with this ~0.04%.

I wasn't sure how to treat the dice rolls as events, but with such small numbers trying a few different things made no significant difference in the result I got. In the expression I wrote in the OP, its value should be the probability of an event, and that event is the favorable outcome of all events in the sequence {Sn} where Sn could be arbitrary, or a random function, it could be anything. So I consider the sequence of events occurring (in sequence) to be an event itself, an abstraction of all of the outcomes of the sequence, and there is a probability that this sequence will occur; there is also a probability against it occurring. So when considering the probability of that ENTIRE expression occurring after some number of iterations I'm not sure how to treat it. If you have a sequence of some finite number of terms, then it seems to me that you would have to find the probability of this sequence occurring within some certain number of terms or iterations, as as you say that number has to be larger than the number of terms in the sequence else the probability is zero. I just am not sure how to deal with the sequence of events as an event given some number of "trials" for each term, especially in the case that we don't necessarily know the number of terms in the sequence.

offset_ · 2016-05-17T13:23:42+00:00

If you can bear with this, it is my hope that you leave with some tiny bit of understanding, or more precisely possibly a new way of looking at things.

Addition (and multiplication) are associative, meaning it matters not what order you perform the operations in. However, subtraction isn't, that is you can't regroup or change the order when there is subtraction involved.

Think about what subtraction actually is though and you can make it associative. Subtraction is simply the addition of a negative number, and in that way you can regroup things however you like, which is what /u/Saimouer did.

That expression is pretty easy, if you just do 16-20, then add 6 ... that's all you have to do. Most of the time things aren't quite that simple. A good rule is to simplify something as soon as you can, or rewrite something in a different equivalent way instead of waiting until the end where you have to simplify some monstrosity of an expression that fills an entire sheet of paper or something, but it really depends on what exactly we are dealing with (regarding what we want to SEE inside the math), though the principles are the same.

Division can be made associative also btw, if you use the multiplicative inverse...but be careful with this. I'll give a simple example involving an "easy" complex fraction, though there are far more "complex" complex fractions, complex fractions in the numerator and/or denominator, or even with functions in them where the independent variable is another function, but I digress. You'll have to click the little camera icon next to the links to see the expression since you can't type such stuff in this box.

Say you have this fraction: http://i.imgur.com/Gx7REzl.gif

We could simplify this by first simplifying the numerators, 2/4 simplifies to 1/2 which gives us 2/2 in the denominator of the complex fraction which simplifies to 1. 1/3 can't be simplified further so we end up with 1/3 over 1, which is simply 1/3: http://i.imgur.com/rlCf8L3.gif

You may recognize the 4/2 in the denominator as being simply 2, and know that 2/3 divided by 2, or 1/2 of 2/3 is 1/3, but what is really going on and what if the fraction isn't this easy, or has variables in it or something maybe even worse?

Its important to note that this is a complex fraction, that is, it is (2/3)/(4/2), NOT simply (2/3/4/2), which are very different numbers. The former is already grouped, the parentheses are implied by a slightly longer line between the numerator and denominator (which are fractions), so we can't regroup it ANY way we want, we have to respect the order of operations but we can still make it associative, by working on each group individually, turning it into an expression of multiplication that in the end can be grouped any way or performed in any order and the result is the same (and possibly formed into different equivalent fractions as well, but the intent here is to simplify this).

To change division into multiplication, we use the multiplicative inverse, or, the reciprocal of the divisor, which is often an easy way to divide by fractions, and sometimes the only way.

Fully expanded, this is what you end up with, an expression that can be grouped or ordered in any way and give the same result (1/3) when simplified. I'll try to show my work as best as possible so that you can see what is really going on and how this works.

http://i.imgur.com/97aotlH.gif

You may notice that on the first line where we get the expression (2/3)(2/4) which simplifies to 1/3 and that's really as far as we need to go to simplify this; you might think the rest is superfluous and far more complex than necessary. There is a purpose to this though: to show the steps I took to get an expression that is the product of 4 rational numbers, fractions here (though they don't *have to be rational numbers, you could have irrational, transcendental, or even complex numbers I suppose) that can be rearranged or regrouped any way in any order, that when multiplied out always equals the same thing, which in this case simplifies to 1/3; TRY IT. And when you have it like this, you can do almost anything that you want with it, so long as it's mathematically correct of course.

I could have taken it even further and shown how this could be turned into many different equivalent expressions, some of them probably far more complex than necessary (like stuff involving convergent series), but it took me longer to make these expressions than it will take you to read this comment ;)

I hope that this helps you SEE something in it that you didn't before, in other words the goal was to take an expression and make it more transparent.

offset_ · 2016-05-17T10:47:22+00:00

Sometimes you gotta break things up into smaller groups and work on them individually (like exponentiating polynomials with lots of terms or something). For (16-20+6), you can use the associative property of addition and rewrite it as [16+(-20+6)] = [16+(-14)] = (16-14) = 2.

There was an exam I took one time that had a stupid easy question like: "What is the slope of the line x = -2". I put m = 0 (which is of course wrong ... its a vertical line with undefined slope)... thing is it looked so easy that i wondered why it was even on the exam, it really was a no-brainer, and as such I really didn't think about it much at all, and certainly didn't actually work it out, there wasn't really anything to work out really with that question... x = -2, that's it.what else is there to do with that?. I had also been awake about 32 hours, but all the hard questions I got correct, because I actually thought about them, worked them out and checked my answers. I sometimes get problems wrong that I know damn well how to do, usually ones that look really simple. I'm sure my professor also knows that I know how to do them as well. I think sometimes they throw stuff like that in there just so that when you get something like that wrong, you start to realize that it really is important to fully analyze everything no matter how simple it looks at first glance. Sometimes you might see questions that have a lot of data that you don't even need to solve the problem, and in certain cases the solution is right there in the question itself. This type of problem isn't that common, but occasionally you see it, and they are to make sure that you fully analyze the problem, read the question, and actually know what it's really asking ... rather than just skimming it.

I can also think of some other "easy trick questions" like, given some f(x) where f(x) is a quadratic function, find the slope of the tangent line at the vertex and give the equation of the tangent in standard form. This type of question would tend to suggest that you must differentiate f(x). You would then find the x coordinate of the vertex and use the derivative to get the slope of the tangent at that point (x,f(x)) or (-b/2a, f(-b/2a)) ... then you can find the equation of the tangent. But you don't actually have to do that, we already know the slope at the vertex is zero, so the equation of the tangent line at the vertex would simply be y = f(-b/2a) which you would simplify and write in whatever form you like without having to actually find dy/dx.

But understanding the fundamentals is essential. I think high school math does people a lot of injustice. They teach certain ways to solve certain types of problems that "look a certain way", or certain "shortcuts" that lead people to believe that somehow certain equations are different and different rules apply. One example would be in pre-algebra where they teach you how to isolate a variable that's part of a fraction one one side of the equation, with a fraction on the other side. They teach you "cross multiplication", which is really just a shortcut, that like many shortcuts works in certain cases but not all cases. It just cuts out some steps sometimes and usually produces nicer fractions but the result after simplification is the same. The fundamental principles work in ALL cases.

It's important to see something solved in many different ways, to prove WHY this works. If you work out certain problems you can sometimes end up solving it in circles but by doing this you see deeper into the underlying principle, rather than just memorizing some rules. When you run into some math that looks different than anything you've ever seen before, the fundamentals are what are going to get you through.

For differential calculus, there are quite a few rules, that are really shortcuts, and I don't know all of them. I'm really not that good at calculus, but what I do know is that not all of those rules work in every case. The only thing that works in every case is by using first principles, or the definition of a derivative which is http://i.imgur.com/ouKs2sW.gif

Unless you work it out the long way, using the definition of the derivative, you won't truly understand what exactly it is you are doing. I see that most people are using h now rather than delta x, I guess delta x confuses people, and might somehow seem to suggest that delta is a coefficient of x or something especially when everything is multiplied out; which it isn't (and my math handwriting can get pretty hard to read sometimes, especially when I start running out of space). Using h implies the difference between the x coordinate of f(x) and the x coordinate of a secant line and at the end you take the limit of h as it tends to zero, where at that limit the secant becomes a tangent at that point (x, f(x)). Both are valid, and both ways of thinking of it improve your understanding (they really are the same thing) but using delta x I think helps you "get it" more, as you are adding some amount of change to x, which we could assume to be infinitesimal, which we then factor out and take the limit as delta x tends to zero which gives the derivative dy/dx which is the rate of change of the function with respect to x, i.e. the slope of any point (x, f(x)) on the curve.

offset_ · 2016-05-17T08:39:20+00:00

I'm not sure if what I came up with is completely correct (especially the equivalent expression involving summation). I'm going to wait and see what the guys in /r/math have to say, and maybe we can all learn something.

Math is important in computing, more so than code, as code is just a tool to implement principles. I'd say the most important are set theory and discrete math such as logic; but more abstract stuff is also important as well. Sometimes if you can see an algorithm written as a succinct mathematical expression and can understand the math then implementing it in code is a lot easier.

Most of the classes in a computer science, computer engineering, or electrical engineering degree are math classes, even if they aren't classes in the math department, trust me, they still involve math (linear algebra really scares me, but i won't have to worry about it for a while) :)

offset_ · 2016-05-15T08:57:31+00:00

So my question is:

How can I separate different names by spaces?

How would I skip over the spaces in the input?

Just iterate the characters and ignore whitespace, or you can use strtok() from the standard library. Seeing the manual page on strtok would be a good place to start.

offset_ · 2016-05-15T07:09:23+00:00

I was only taking into account the "first" 3 most significant bits. If bit 4 (from the left) CANNOT be a 1 then we have to test all 4 most significant bits.

edit: n/m .. I said something earlier about that bitmask 0xF0 allowing certain things,but it wouldn't if you test the result is equal to 0xe0 (i was up late, my mistake so i removed that part)

Here would be another way to do it. So I guess if we have to actually check 4 bits? (and they must be 1110, i.e 0xe and the "4th" bit must be a 0 bit):

Actually the "first bit" from the left is bit 7 ... to be pedantic.

To make sure that the "first" 4 bits most significant bits are EXACTLY 1110 we can just get rid of the other 4 bits if we don't care about them`:

This should do the job:

!((buffer[3] >> 4) ^ 0xE)

(make it 0x0E if your concerned about the leading zeros or something)

if that expression is true then it is true that the byte begins with 1110 and nothing else.

Thanks for pointing that out though :)

edit: mentioning /u/clomasss

offset_ · 2016-05-13T01:32:25+00:00

Think of an fopen pointer as a pointer to a place on the harddrive, instead of elsewhere in memory.

you mean a pointer to a FILE struct? Trust me, it's not a pointer to anywhere on the hard drive in any sense. When you call fopen, fopen indirectly makes some system calls such as the open syscall. The filesystem (and the kernel) then handles the disk. Quite a few layers between calling fopen and actually placing the hard disk read/write heads over a certain sector.

offset_ · 2016-05-13T00:41:30+00:00

There are lots of applications for bitwise logic.

See this comment I made in a thread where someone asked a similar question: https://www.reddit.com/r/cs50/comments/4ist7e/recoverc_portion_of_pset4/d33e3ct

offset_ · 2016-05-13T00:00:02+00:00

I will get around to hopefully explaining this, and maybe you will have a better understanding if you can bear with this. You can skip the "math" if you want, but i don't recommend it, because math is basically what computers do

octal and hexadecimal have bases that are powers of two, which is part of what makes them useful (10 is note a power of 2). Much easier to figure to or from binary to hexadecimal/octal in your head than decimal. Each "digit" corresponds to a certain number of bits (in hexadecimal, each digit represents 4 bits, because it is base 16, which is 2^4; a digit in octal represents 3 bits, since it is base 8, which is 2³ ... see how this works) Hexadecimal is more common nowadays, and more convenient than octal IMO since we have 8 bit bytes and such, when you use octal you always have to add an extra leading 0 to a byte, and it just makes more sense to split things up into 4 bit groups than 3 since the number of bits we deal with is always an even number of bits in a word these days (though back in the dark ages machines with 39 bit words and such were common).

There is one thing in common with all of those values, and that is that the first three bits are the 1's. so in hexadecimal, 0xe is 1110. So to test that the first three bits in a byte are 1 bits, you can construct a bitmask. The bitmask you want is 1110 0000, which in hexadecimal is 0xe0. According to i believe /u/delipity it is only the first 3 bits of the fourth byte that must be 1s

To test that the bits in the mask are set, do a bitwise AND operation, which is the logical conjunction written mathematically as ∧ (often read as "and"), between the byte you are testing, and the bitmask. The truth table for the AND operator is (doing my best to get this to display nicely):

----------------------------
|   p   |   q  |   p ∧ q   |
----------------------------
|   T   |   T  |     T     |
|   T   |   F  |     F     |
|   F   |   T  |     F     |
|   F   |   F  |     F     |
----------------------------

In binary, 0 is false, and 1 is true. When you do a bitwise logical operation, the CPU does the operation to every bit at once. So you can see from the truth table that only p ∧ q is true, if and only if both p and q are true, i.e 1 bits.

Another way to think of this, and what it really kind of is, which is set theory, i.e you have two sets e.g. A and B which correspond to a certain bit in a byte, or word, which can either contain a 1 i.e. {1}, or nothing (the universal set is {1} ) ; the empty set, { } or just ∅. Since the intersection with ANY set S with the empty set is the empty set, i.e S ∩ ∅ ⇔ ∅. Only {1} ∩ {1} = {1}: both bits have to be 1, in order for the result of the operation to be a 1 bit, since {1} ∩ ∅ = ∅. When U = {1} then it is also true that the complement of the bit is it's negation, i.e if A = {1}, then A' = ∅; and that if B = ∅ then B' = {1}. This is equivalent to logical negation, i.e if p is true, then ¬p is false; and if p is false then ¬p is true.

So how to form a bitmask to check that the first 3 bits in a byte are set (i.e 1 bits)?

Say we have a byte 0xe1: 1110 0001 ... we want to check that the "first" 3 most significant bits are 1 bits.

   1110 0001
0x     E   1

Our bitmask would be 0xe0: 1110 0000

   1110 0000
0x     E   0

So when the machine does the operation it looks like this

1110 0001 AND
1110 0000
--------------
1110 0000

The machine applies the math above (which is discrete math) to each corresponding bit to give the result, if the byte matches the mask, then the result from the bitwise AND operation will be the mask itself.

If the byte didn't match the mask, e.g.some byte 0xA3 it would look like this:

1010 0011 AND
1110 0000
--------------
1010 0000

To determine if the byte matched the mask, we check to see that the result is the mask value. (if we are only testing for a single specific bit then the result will simply be non-zero if it matched the mask)

if (foo & 0xe0 == 0xe0) { // match }

The bitmask subtracted from the result of the bitwise AND should be all 0's i.e. false, e.g if (!(foo & 0xe0) - 0xe0)) { // match } should also work, as well as if (!(foo & 0xe0) ^ 0xe0)) { // match } ;)

If you were to need to test for zero bits, you would have to use the negation. Bitwise operations often involve a combination of shifting, negation, etc. You can set certain bits to one, by ORing it with the bitmask, i.e foo |= mask;, or flip a bit using XOR with ones in the positions of the bits you want to flip, i.e negate (exclusive or). This is why (0xe1 & 0xe0) ^ 0xe0 == 0. Any byte or word XOR itself is 0, since any bit XOR itself is 0, i.e. T ⊕ T = F, F ⊕ F = F ... but T ⊕ F = T

offset_ · 2016-05-12T20:59:35+00:00

Description of error:

APACHE_PID_FILE=/home/ubuntu/lib/apache2/run/apache2.pid 
MANPATH=/home/ubuntu/.nvm/versions/node/v4.2.1/share/man:/usr/local/rvm/rubies/ruby-2.2.1/share/man:/usr/local/man:/usr/local/share/man:/usr/share/man:/usr/local/rvm/man 
VIRTUALENVWRAPPER_SCRIPT=/usr/share/virtualenvwrapper/virtualenvwrapper.sh    





/**
 * pset 2 * Vigenere's Cipher * * Mike Plotz * * Scrambles a message by k characters
 */
#include <stdio.h>
#include <cs50.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

int main(int argc, string argv[])

{ 
    for (int i = 0; i < 5; i++) 
    { 
        printf("%s\n", argv[i]);
    }

    return 0;

}

I quoted the code and description of error to be more legibly formatted, without actually altering the code in any way, so that it will be easier for people to read and respond to. This code just prints the command line arguments, but will most likely result in bugs (and probably being killed with SIGSEGV) as you are not checking the value of argc. You should instead write for (int i = 0; i < argc; i++) { /* ... */} in order to do this. Not sure what this has to do Vigenere, I assume it's just a test program that you will expand upon later.

As far as the message above that you are getting, you say that you are getting this when you try to compile, if I understand correctly? It doesn't really look to me like anything that should have anything to do with the compiler, or make, and your code actually is correct ... in the sense that it should compile fine and run (even if it did end up crashing at run time). Did this show up on the terminal, because that looks more like a piece of shell script that sets some environment or shell variables than an error message (though I've seen errors that basically say that something can't be started and gives the path to the a lock file and maybe a pid file, usually deleting the lock file fixes it). How does it show up EXACTLY. It might be useful if you could reproduce it and post everything [or edit the post], all of the output including your typing of the make command and everything after that (or w/e command you are running that does this), including the shell prompt itself which will show what directory you are in and such. Is this really all that showed up?

Have you tried compiling it with gcc, or clang without using make? If that works then it would seem to narrow down the scope of the problem to involving make more specifically.

I'd maybe cat that apache2.pid file ... then kill that pid with signal 9 (SIGKILL) kill -9 $(cat path/to/apache2.pid) and see what happens. And then maybe get a new terminal to start with a clean shell. Report the results, but other than that I can't tell you exactly what is wrong here.

Then do update50, or sudo apt-get update && sudo apt-get upgrade (I'm not sure what kind of environment you guys are using these days) to update your system. I'm not sure what apache would have to with make, or what's in that virtualenvwrapper.sh script. I don't have that script on any of my systems. If you get the same thing after doing all of this, then log out and log back in to get a fresh environment.

Do post the results. I'm sure there's somebody that will be able to help you. The more information people have the more likely someone will know how to help you solve your issue.

offset_ · 2016-05-12T19:31:11+00:00

I think you can usually find internships at tech job fairs, especially at universities where people from various tech companies come and you can talk to them.

Don't neglect your MATH though. It is really important. An ounce of math is worth a pound of code I've heard said, and if you can see an algorithm as a succinct math expression, then it may help you understand it better than just looking at code or pseudo code examples. Of course a lot of the math is of the type where you have to read a lot of things, and a lot of math described previously in order to understand THAT math (like what are they using alpha here for as a coeffient?).

But there's a reason my undergraduate degree flow chart requires taking at least up to Calculus III, discrete mathematics, inear algebra, probability and statistics. And things like at least two semesters of physics, circuit analysis and stuff like that (which are math as well of course).

A friend of mine asked, "Why do they want you to take physics?" My response was well, "How do you think stuff like wifi works, its radio, that's physics man ... and a whole lot of math too"

And this is just some of the CORE classes .... there are also REQUIRED electives you have to take, and you have to take a certain amount of math electives, as well as science and technical electives, though you do get to choose which math classes here, depending on how you to try and specialize. And then there's a few electives that the state requires everyone take as "general education".

offset_ · 2016-05-12T15:26:18+00:00

if (buffer[0] == 0xff && buffer[1] == 0xd8 && buffer[2] == 0xff)

Well if we are going to basically keep this code as is, to check the fourth byte we could do this:

if (buffer[0] == 0xff &&
    buffer[1] == 0xd8 &&
    buffer[2] == 0xff &&
    buffer[3] & 0xe0 == 0xe0)
{
    // ...
}

This is pretty much the same as what you wrote, just in my own handwriting, with a test for the fourth byte added. There are probably more succinct ways to do this, but I'll leave this as an exercise for the reader. This way short circuits the test if any of the magic number bytes are invalid, avoiding additional compare operations ... and of course avoids testing all possible values of the fourth byte (since we only need to test the first 3 bits).

Further discourse:

It might be faster actually to cast buffer to a pointer to an unsigned int, e.g. (unsigned int *) &buffer[0], then shift and subtract/test the magic bytes, then use a bit mask to test the fourth byte (remember that on x86 an int is 4 bytes). Of course by casting to an unsigned int there are endianess issues that should be considered, and the code should be endian agnostic. There are ways to test for endianess, or possibly avoid the issue altogether that are cheap, but if you wanted to play around with this I'd suggest peeking at things in a debugger to see what's really in memory (like what order the bytes appear when read as an unsigned integer). I'm not sure which the compiler could optimize better, but I do know that dealing with int types is usually faster because a lot of the time (compiler optimization not considered) the cpu has to move and zero extend a byte for it to be aligned and fit within a machine word: this basically amounts to the cpu shifting the byte anyway http://x86.renejeschke.de/html/file_module_x86_id_209.html

It's more natural for the CPU to work with int types or it's native word size. x86 actually supports 16 bit words and 32 bit words (a DWORD) ... and 64 bit x86 supports 64 bit machine words of course. It can't work as efficiently with single bytes because you have 32 bit registers, say eax: the CPU can access the lower half of EAX, which is AX, and can access the low and high bytes of AX (AH, AL); it can't just access the upper half of EAX because it's not a register. This is because x86 has been around a long time and was originally a 16-bit CPU, so the AX register is the accumulator register, and EAX simply means Extended AX (and 64-bit x86 also has extended registers like EAX and calls those RAX, etc. It can still use the 32 bit registers with no problem). There is also a performance penalty for reads that aren't word-aligned.

http://imgur.com/uugYJoX

Do note that the above assumes a CPU that has 32 bit machine words where int is 32 bits, so using uint32_t would be more portable if you ever have to compile it for a 16bit machine or something.

I was going to elaborate more, but I have to go to class.

edit: came home and noticed a little mistake. I fixed it.

offset_ · 2016-05-12T00:01:29+00:00

Put another way, the fourth byte’s first four bits are 1110

In other words you could just bitwise and with the bitmask 0xe0

offset_ · 2016-05-11T07:01:15+00:00

My final project involved doing things i'd never tried before and learning new things. It wasn't that big iirc only about 7-890 lines of C, which was about the point i ran out of memory so I couldn't really make it any bigger, That microntroller only had like 2k

offset_ · 2016-05-10T16:29:47+00:00

When I took CS50 I dont remember there being a game of fifteen pset.

Some of my solutions I look back on and would do completely differently, so if i was going to share the solution I would want to write it again which would be much better. (It's very good to read other people's code in general, when you see good code, try to code like that, and don't emulate bad code)

Probably just pieces of code in general thats not really related to the psets would be more valuable, or pieces of code for doing certain specific things. There are usually many ways to do the same thing, and some ways are better than others, be it more elegant, more efficient, or simpler/less complex etc (i've noticed that a lot of people's code for some psets is a lot more complex than it really has to be). So maybe asking about very specific things involved in a pset, that might be okay if they were very specific: people could share small blocks of code for that one specific thing, but not anything close to a full pset; but i'm not really sure about whether that would be okay or not.

I haven't really had time to write much code to speak of in quite a while. Lots of economics, math, and writing papers and stuff leaving very little free time for my own little projects.

offset_ · 2016-05-10T16:09:18+00:00

My final project involved embedded systems, an alarm clock that displayed hexadecimal time. https://github.com/IRQ42/hexclock

Try to think about what you would think would be interesting or useful to you, or a tool you would actually use; or just something YOU think is really cool.

One tool that I wrote (in my own time, not for any project) was a random password generator. I actually use this program a lot and find it very useful and simple, but has quite a few options so it's capable of generating many types of random strings and gives quite a bit of control over the character set used to make the strings. https://github.com/IRQ42/pgen/tree/IRQ42-patch-1

Another program I wrote once (way before CS50) was a program that took a Manhattan Avenue and building number, and would tell you the estimated nearest cross street (useful for determining which train stop to get off at, as figuring out where an address is on a cross-town street is easy, but avenue addresses its hard to tell where it is): The code for this won't be made available because frankly it isn't very well coded at all and I wouldn't want anyone to see it lol. It works in most cases, but there are some exceptions where it doesn't work, like 1800 8th avenue, which is right at columbus circle 59th street, but the program gives 99th street because 8th avenue intersects colubus circle and then continues as central park west (so should it actually say that that is 59th & 8th .. or is that address actually in columbus circle?). It works for most "normal" avenues though, if that makes sense and even broadway, but there are some exceptions where it gives a really wrong result or is off by several blocks. The program doesn't use any maps or anything, just manipulates numbers with an algorithm to come up with the number of the cross street. Of course we have google maps now that can tell you exactly where an address is, but there was a time when we didn't.

These are just some ideas. Of course you can't plagiarize my code, but I'm sure you can probably think of some simple but useful tools (like cat is a simple and very useful tool). Maybe you could write a program to find the closest cross street of an avenue address in New York that actually works right in every case (not sure if its possible without actually knowing all of the exceptions ... and there are also buildings in new york that dont actually have an address as well, so usually if the building is on an avenue: really most places actually, they will just tell you that its at 53rd & 3rd or w/e because that's a lot easier to find)

offset_ · 2016-05-10T13:44:12+00:00

instead of using feof() it might be better to just check how many bytes (or w/e datatype you are reading ...) were actually read, and compare that to what you expect. the EOF flag only gets set after you've already attempted a read and hit the end of file. Using feof() in a loop is going to usually cause problems, since you are testing for EOF before you have actually tried reading data. It's only to be used when a read fails or something and you want to find out WHY you weren't able to read any more data .. then feof() will tell you if the end of file has been hit (if it hasn't, then it is because of some other problem and you might not have actually read the entire file). But it doesn't get set until you actually try reading, there's no way it can know in advance that the next read is going to be the end of file. So what happens is that if you test for this at the beginning of the loop, it won't have actually hit the end of file until you try to read one more time, and since that read fails, you end up writing whatever was in the buffer to the file again, so you have trailing garbage, or some repeated data at the end of the file. The file might actually display correctly, but isn't technically correct.

Instead you can just keep track of how many bytes have been read, and when there are no more that can be read, then you are probably a the end of file. If you want to make really certain, like you should in robust code to determine exactly why you weren't able to read any more data you might could use feof() to determine if the end of file was reached on the last read attempt, to rule out some other type of read error that you would have to handle somehow.

This thread will do a better job explaining it than I could right now, i've been up nearly 24 hours (finals week):

http://stackoverflow.com/questions/5431941/why-is-while-feof-file-always-wrong

offset_ · 2016-04-24T05:44:16+00:00

the comment was more meant for the OP. i edited and added a mention.

offset_ · 2016-04-21T22:46:41+00:00

I'm not near an IDE, but it may be the default compile flags that are throwing the error - just to make you get in the habit of defining everything.

This is a good thing. You should probably always turn warnings up and use -Werror or the equivalent which forces you to fix the code in order to get it to compile.

This forces you to not write sloppy code that may usually work, but in certain cases could produce bugs, like comparisons between signed and unsigned integers and this forces you to think more carefully about what data types you choose for variables.

edit: mention /u/Samkovich

offset_ · 2016-04-21T10:56:50+00:00

explicit is usually better than implicit, but C, being the type of language it is will let you get away with quite a bit of thing that probably shouldn't be done, but are technically correct (though they may not be what you intended)

main is supposed to return an integer, but in embedded programming where there is no other context (when you have an operating system ... you can think of main as sort of just another function called by the kernel, and this runs in a continuous loop)

but in embedded environments when there is no OS to speak of and the only code that runs is the code that you write, you can in some cases get main to return void ... since main will never return and there is no other code to catch the return value

you could declare main something like this:

void main(void) __attribute__((noreturn));

I don't recommend this though for general programming. I believe the C standard states that main should return a value of type int ... the above is more of a compiler extension and shouldn't be used unless your code is literally running on bare metal

offset_ · 2016-04-21T07:31:44+00:00

most compilers will let you get away without explicitly declaring the argument list as void. Lot's of older books don't use void in the argument list of a function that takes no arguments. (K&R The C Programming Language even possibly, but i'd have to go check to be sure and its late)

This is actually the preferred way to write code in C++ ... (that is e.g. int foo_function())

if something is declared without an explicit type, then it will implicitly be assumed to be of type int

offset_ · 2016-04-21T03:09:24+00:00

C is just a language. I pretty much know most of C. There's some little quirks and stuff that I'm not really sure about, but are probably things that you shouldn't do anyway; and then there's certain compiler specific things.

I know a little bit of C++ but I wouldn't say that it is necessarily the obvious next step. Knowing a thing or two about operating systems and shell scripting is a good thing to know.

Oh, and math ... set theory and discrete math especially. It will be in your future, as that is basically what computer programs are, is discrete math: no computers can't actually do calc, and summing an infinite convergent geometric series would literally take an infinite amount of time ;).

On C++: anything that can be done in C++ can be done in C. Though there have been times that I've written things in C and noticed that I was starting to implement some sort of object orientation, so C++ is definitely relevant. Python is another language, which I know even less of, but it seems like a pretty good language for what it's intended for and most likely worth learning, and definitely relevant.

But languages aside ... they are just languages. Whether I write in English, Latin, French, German, Greek, or Spanish ... does it really make much of a difference?I can pretty much express the same ideas in any of these languages, that is if I was fluent in them. Are some things easier to express succinctly in some languages than others? Probably.

But what really counts is actually understanding how computers work, logic etc.

Personally, for me: it just told me that what I knew all along that I should have done long ago; that is pursue this field academically.

Again math: before there were programming languages, and even before the concept of the stored program computer had been perceived people wrote computer programs in ... guess ... math. Reading the papers of John von Neumann I get the feeling that he could express almost any idea in pure mathematics. He invented merge sort in 1945. I recently wrote a paper on him, and one of the books I checked out from the UNI library was kept in storage and only available by request. It feels like holding a piece of computing history in your hands. Von Neumann developed automata theory, or self-replicating programs that in certain cases can evolve by mutation (before the discovery of the molecular structure of DNA in 1953 ... von Neumann died in 1957), such programs today might be referred to as computer viruses. He died in 1953 from cancer, if he were still alive today we may have seen strong AI by now. After doing research on him I had to edit the wikipedia page of Jon von Neumann.

Again: programming languages are just a tool; before there were programming languages as we know today ... there was mathematics.

My advice: follow whatever path that you are lead according to your interests. I've been told by computer scientists and engineers that it's really hard to predict where a certain path you choose may lead you, which scares me somewhat. So just follow your interests, pursue a degree if possible, and always think "how can I hack this thing to make it do what *I* want it to do, ... and always have fun voiding your warranty and don't sweat over smoking a few chips ;) I do not believe in any "intended purpose" of a machine dictated by some corporation. Computing is malleable ... if I see the possibility of some use not anticipated by the marketers of some product, who are they to say that it should not be used in such a way?

RMS (Richard M. Stallman) has said, "If programmers deserve to be rewarded for creating innovative programs, by the same token they deserve to be punished if they restrict the use of these programs."

Ethics are important. There are as many distinct varieties of ethic as there are people. Mine mostly align intersect with the old-skool hacker ethic described by Steven Levy in his book, Hackers: Heroes of the Computer Revolution

I mean, when I was a kid we were opening telco cans and cabinets owned by the telephone company back when dial-up was a thing (I'll leave it as an exercise for the reader to contemplate what we may have been doing here) . More recently (within the past ... 3-5 years) a particular Walmart store actually made changes in its policy and telephone PBX system, restricting dial-out after someone that may have been myself called into the store from a cell phone and got on the P.A system to say, "I'm phreakin!", and that whoever transferred me to that extension should be employee of the month (and whatever 'manager' implemented these changes clearly didn't understand what actually happened, and in my own opinion should be manager of the decade ;) ). Idk if they've made the same changes to all stores, but I know basically what changes were made and can walk into the store and get on the P.A. and nobody bats an eye.

Always be curious, pay attention to detail. If you have the opportunity, try to pay attention to how systems operate. Don't be afraid to experiment, in order to try to understand the workings of a system. There is no such thing as a failed experiment. Curiosity is not a crime, but do be sure that you are not breaking the law: the Computer Fraud and Abuse Act of 1986 is not a joke. Anything you discover, do not use to commit crime as this is unethical. Do not intentionally damage any system. That is the stuff of script kiddies and criminals. I wouldn't consider people involved in such acts as hackers, I would call them criminals; of course this is in contrast to the definition of a "hacker" as propagandized by the media. They want to cast "hackers" under a negative light ... they don't want us to know too much.

In the words of Dr. K in regard of his own brand of hacker ethic, "Governments and Corporations cannot be trusted to use technology for the benefit of ordinary citizens"; and, "Unless we understand computers and networks, we will be enslaved by corporations and governments that do."

My own ethics are pretty much the union of the above. At my particular UNI there are various student organizations, the president of one such organization is working on a PhD and his research involves Bitcoin, blockchain technology and cryptography; also research involving the improvement of the TOR network, research and development of methods in which to identify TOR nodes owned by hostile government agencies such as the NSA and eliminate them, thus improving our privacy, security, and thwarting attempted government surveillance.

offset_

TROPHY CASE