CornBurrito
Member
How many 1s are in 567,896?
-
Hey, guest user. Hope you're enjoying NeoGAF! Have you considered registering for an account? Come join us and add your take to the daily discourse.
Programming |OT| C is better than C++! No, C++ is better than C
- Thread starter Kikarian
- Start date
How many 1s are in 567,896?
JeTmAn81
Member
The sum of the 1's in the two halves of that number:
0000000000001000
and
1010101001011000
Both of which exist as entries in the lookup table since they're individually 16-bit numbers.
cpp_is_king
Member
It started with no scripting, just HTML which were just text documents with hyperlinks. Over time people started to make more elaborate documents in terms of presentation and this lead to people wanting to do more with them and adding new features. One of the things they decided to add were some light scripting features. Back in these days things were not very standard, Javascript was famously created in 10 days by some developers at Netscape. Eventually they brought it to the ECMA to create a standard so pages could be more interoperable between browsers. MS was not really on board with this and was uninterested in client-side scripting, choosing to push the server-side method of updating content via forms which had existed long before (ASP, PHP, CGI to interface with other popular languages of the time, etc). Eventually they caved and caused a bit of a schism where separate javascript standards going at the same time and eventually this settled with ECMAscript 5.
So to more succinctly answer, it was more a question about whether to have scripting or not. Javascript was created to add scripting to HTML documents without the use of heavy and lower-level languages like Java and C. Note that for a long time Java applets were a thing to get interactivity in applications, and MS did push for VBScript as a scripting language as well but it didn't win out.
insert_username_here
Member
Client side is less flexible when it comes to using different languages, it would have to be supported by the browser or the user would need to install a plug-in and the language maintainers would have to make a plug-in for every single commonly used browser. So because of this Javascript is just more convenient. Server side doesn't have this kind of problem because it is up to the creators of the website to install the necessary files to support a language. Until webassembly is ready for mainstream use, we are stuck with javascript.
CornBurrito
Member
So I'm going to start applying for CS internships. I only have about 4 completed CS courses under my belt (consider my a freshman I suppose... or perhaps someone just starting their sophmore term), and am just about to complete 2 more.
Intro CS I, Intro CS II, Discrete Structures in CS, Usability Engineering (joke course), Computer Architecture, Data Structures.
I have a few class projects that maybe sort of I can put on a resume.
Does anyone know what a freshman/sophmore resume should look like for CS internships? And then would anyone be willing to look over mine sometime next week?
Intro CS I, Intro CS II, Discrete Structures in CS, Usability Engineering (joke course), Computer Architecture, Data Structures.
I have a few class projects that maybe sort of I can put on a resume.
Does anyone know what a freshman/sophmore resume should look like for CS internships? And then would anyone be willing to look over mine sometime next week?
Spoiled Milk
Banned
This is wrong. I will illustrate why it is wrong in the typical way.
Why is webassembly going to free us from JavaScript on the client-side?
Because webassembly is a fast, near-native speed executable encoding that is safe for the web.
But what does that have to do with JavaScript, and how does it free us?
Well, people will be able to ship WebAssembly binaries and their browser will be compatible.
That sounds useful. How do I make a WebAssembly binary?
Simple. You write in the programming language of your choice, run it through a compiler, and a web-asm binary pops out.
So the bridge is the compiler, yes? By compiling to a uniform format, many languages can be treated by the same endpoint.
Yes, that is the idea.
Then why not compile to JavaScript?
Because it is slower.
But won't JavaScript be faster because it can be compiled to Web Assembly?
This is true.
And won't JavaScript be easier to compile to because it is a high level language?
This is also true. So then why don't people already compile to JavaScript?
In fact, they do. There are many languages that do this already:
- Elixir
- Clojurescript
- Fable
- Purescript
- Typescript
- GHC2JS
Etc. So what is the point of WebAssembly, then?
I suppose it is to make JavaScript faster, and has nothing to do with inter-language compatibility.
This is incorrect. Web Assembly (WASM) is mainly trying to improve the speed of parsing and transmission by providing a binary format that's quick to parse and a little less esoteric than ASM.js. Under the hood it works just like ASM.js which itself is just a series of optimizations built into existing JS engines due to typing guarantees and exists in all non-Webkit browsers today (and even they are implementing it). WASM will do nothing for JS that doesn't already exist, and the real use case for ASM.js is to allow companies to port C++ code to the web with minimal rewrite (other languages are able to leverage it but it's not the primary case). JS has a different track, since the JS engines do have type optimizations but cannot be applied directly on JS code due to things like sparse arrays and other runtime type changes these will be addressed via Strong Mode (also referred to as Sound Mode) which is an opt-in mode like Strict Mode but removes some of the looser modification rules to get better compiler optimization. Beyond that they will move into Typed Javascript which currently is planned to be built on top of Typescript.
Definitely throw projects on there even if they're just coursework. Describe what you did, why, and how. Try to host the code on GitHub or somewhere else if you can. Companies understand that you're a freshman/sophomore and what to expect. r/cscareerquestions is a decent resource for this sort of thing, especially if you want a lot of anonymous people's opinions.
Holundrian
Unconfirmed Member
Dunno if this is the right thread to ask for but anyone have a recommendation on a good book that could give me enough fundamental understanding of graphics programming so I can build on that and dive in deeper where I need to?
Like I've got a good book that covers the math on that front but I feel like I want something that covers more the programming front on the topic(like important concepts) maybe even going into the common APIs and what I should know about them.
Big question probably but since I'm a noob on the topic right now I don't know how to ask this better, I'm not even sure if what I'm seeking is smart and just sticking to the math side is enough.
Like I've got a good book that covers the math on that front but I feel like I want something that covers more the programming front on the topic(like important concepts) maybe even going into the common APIs and what I should know about them.
Big question probably but since I'm a noob on the topic right now I don't know how to ask this better, I'm not even sure if what I'm seeking is smart and just sticking to the math side is enough.
Moral Panic
Member
Github down, productivity gone.
Could be worse, could be Github and Stackoverflow
I always wondered why GIT never had a feature to pull updates from local repositories on the network first before trying to pull from the remote. In either case if you have a coworker with an updated copy you add them as a remote.
You can do that. You'd just have to have your coworker run the git daemon on their machine and add them as a remote on your local repository.
Keep an open mind. It's going to be pretty different from what you're used to. If you keep working with it, it will eventually click.
And then your pupils dilate and you don't stop talking about functional programming until your friends can't stand you.
Right, that's what I said, but I was thinking more of an ability for it to pull from several sources in a less centralized fashion, kinda like Bittorrent.
PetriP-TNT
Member
Well, there are things like gittorrent (https://github.com/cjb/GitTorrent) that can do that.
Or just clone the repos directly over some other protocol if you are on the same network with your co-worker.
Like having multiple remotes? Or are you talking about having some kind of service that will match you up with remotes automagically?
lol I kinda know somebody who is like that.
Spoiled Milk
Banned
Can confirm.
Yeah this is pretty similar to what I was thinking in terms of process (although it goes way further with the Bitcoin identity system and Bittorrent compatibility). Not entirely practical but really cool.
Not really the sort of caching or redundancy stuff you guys seem to want, but in the vein of P2P version control, I'm wondering if you could set up a connection between coworkers to share information about changes being made as they are being made. The hope then would be that merge conflicts could be detected before you try to merge, so you'd resolve them upfront instead of later. It would be n-1 to the power n connections, so you'd have to break it down into small groups, else you'd run into limitations (technical, but also human limitations way before that).
Not that I'm aware but I'm also curious. One of my ideas was a code editor that works like Google Docs. You would see other people adding code in real time and it would essentially always be merging in real time or close to it with the idea that the smallest possible merge is always best. Of course as a pure concept this wouldn't actually work in real cases because you'd get weird half-merges and incomplete features that would break things but perhaps you could play around with when merges are considered "safe" and non-breaking or allow users to manually merge blocks as they come in and show them in real-time but ignore them in terms of compilation. At the very least you'd know when two people are in the same area.
I think the Saros plugin for Eclipse does real-time collaborative code editing. We had to do it for a school lab, worked fine. Only two people though.
You could perhaps only show what other people are doing in real time, and every time some changes have been made and tests run successfully the changes are automatically pushed to everyone else. And you'd encourage people to do things in small steps, which is probably good practice anyway.
And/or maybe you could take a page out of multi threading and let people "lock" files (or maybe some smaller unit of code, functions/classes) so only they can edit them.
This was sorta what I was thinking though it's hard to even imagine the workflow without a prototype or a similar piece of software, the idea itself might not be workable, but it sounded like it had promise.
I'd also like to see semantically aware version control that can merge changes based on the actual code structure rather than code lines.
Spoiled Milk
Banned
So you subtract the end minus the beginning and easily get the number of elements. 11 - 1 = 10. Not only that, but if you start indexing at 0, it gets even easier.
for i in range(0, 10):
print(i)
And now take the two points into consideration while iterating over an array.
for i in range(0, len(array)):
print(array)
No need to do a -1.
Spoiled Milk
Banned
So said our Lord and Savior Dijkstra, blessed is his name.
cpp_is_king
Member
While all of the above about python ranges are true, there's another more fundamental reason why (1,11) does not include the number 11. Suppose it did. How would you write the loop? Here's a couple of ways:
Any thoughts on which one is the "best"? On the one hand, the first one is the most readable. You don't have to do some mental subtraction by 1, and the bounds of the range are just "there". But there's a HUGE drawback. It requires a < operator. So great, you can use it for numbers, but what about arbitrary objects? Not every set of data can be ordered.
For that reason, the 3rd approach is the best. It is the most generic because it only requires you to be able to check for equality. Now, sure, you could do something like this:
But wow, that's some shitty code, right? So the "best" and most efficient way to write this loop is to loop until you are one past the last element.
In fact, this is the way C++ does it too. For example, if you want to iterate over an STL vector, you would write this:
Here, items.end(), if you tried to dereference it, you'd get an error, because it's not one of the items of the sequence. Using proper mathematical notation, valid range of the sequence is the half open interval [v.begin(), v.end())
Iterating over half open intervals as opposed to closed intervals is so convenient it's almost universally adopted in modern languages.
Code:
i = 0
while i <= 11:
print("I can count to ", i)
i = i + 1
i = 0
while i < 12:
print("I can count to ", i)
i = i + 1
i = 0
while i != 12:
print("I can count to ", i)
i = i + 1Any thoughts on which one is the "best"? On the one hand, the first one is the most readable. You don't have to do some mental subtraction by 1, and the bounds of the range are just "there". But there's a HUGE drawback. It requires a < operator. So great, you can use it for numbers, but what about arbitrary objects? Not every set of data can be ordered.
For that reason, the 3rd approach is the best. It is the most generic because it only requires you to be able to check for equality. Now, sure, you could do something like this:
Code:
i = 0
last = False
while not Last:
if i == 11:
last = True
print("I can count to ", i)
i = i + 1But wow, that's some shitty code, right? So the "best" and most efficient way to write this loop is to loop until you are one past the last element.
In fact, this is the way C++ does it too. For example, if you want to iterate over an STL vector, you would write this:
Code:
std::vector<int> items;
for (auto b = items.begin(); b != items.end(); ++i)
cout << "I can count to " << i << endl;Here, items.end(), if you tried to dereference it, you'd get an error, because it's not one of the items of the sequence. Using proper mathematical notation, valid range of the sequence is the half open interval [v.begin(), v.end())
Iterating over half open intervals as opposed to closed intervals is so convenient it's almost universally adopted in modern languages.
PetriP-TNT
Member
runningjoke
Member
The same but with range(1, 10) ? In PHP range(1, 11) includes 11 and that's what I'd expect to happen.
That's interesting, but I don't completely buy it...
* You can write the loop without the < and with 11 :
Code:
i = 0
repeat
print("I can count to ", i)
i = i + 1
until i = 11
Code:
i = 0
while true :
print("I can count to ", i)
i = i + 1
if i == 11 : breakGranted, the first one is neither Python nor C, and the second less common/nice, but when you're writing the compiler/interpreter, I don't think you'll make decisions on such small details.
* The range USE the < operator since range(11,1) is empty and not one that would give an infinite loop (so your two first examples are the only ones that match Python behavior there, even if I'm sure that's the third that is used in the loop (and first < last only checked once at start)
* indeed, < is not available for all types, but loops in Python stop when StopIteration is raised... range is an integer-only construct, they could have designed it to raise StopIteration after yielding 11.
I think that
is the main reason. It's usually done that way, and done that way because range(10) gives you 10 iterations since you begin at 0.
Having to deal with students that learn, at the same time:
- Python, where lists (tables in fact) begin at 0 and where range(1,5) or 1:5 slice is 1, 2, 3, 4
- Scilab, where vectors begin at 1 and where 1:5 is 1, 2, 3, 4, 5
- Caml, where vectors begin at 0 and where for i=1 to 5 is 1, 2, 3, 4, 5
I would have liked them to settle on a standard more often. There have even been mistakes in loops in national exams.
Spoiled Milk
Banned
Nice read with which I agree (but that's basically "range(10) should have 10 elements, and counts should begin at 0"), and great conclusion ^_^
Although I'm not sure that tables that begin at 0 is really a philosophical choice in C... in such a low-level language, table indexes are just pointer arithmetics (a just translate into *(a+b)) so they would probably never have settled on tables that start indexing at 1... or they would have wasted memory (not a chance), or had tables whose address isn't the start of the allocated memory...
This handwriting is hypnotizing
It's a matter of choice/habit, and I think having 1..10 is more natural. I've already done mistakes in PHP because of it.
Note that in Python, it's not always logical:
random.randint(1, 11) gives a random integer in 1, 2, ..., 10, 11
AFAIK, some people complained, so they added
random.randrange(1, 11) that gives a random integer in 1, 2, ..., 9, 10
But things become nasty when people from numpy started doing things their way (and it's worsening) and decided that
numpy.random.randint(1, 11) gives a random integer in 1, 2, ..., 9, 10
Now, you have to fish for the import to know how randint behave... :/
Spoiled Milk
Banned
Making a choice to have array access match the semantics of pointer arithmetic was definitely a philosophical choice, and probably the most important choice it ever made, i.e. that the programmer is programming against a machine with weakly coercible abstractions. And it was not the first time this choice had to be made.
You see, ALGOL, Fortran, and BCPL (from which B derived, from which C derived) had for loops which were completely exclusive. From Wikipedia, a matrix algorithm in ALGOL 60:
Code:
procedure Absmax(a) Size:(n, m) Result:(y) Subscripts:(i, k);
value n, m; array a; integer n, m, i, k; real y;
comment The absolute greatest element of the matrix a, of size n by m,
is transferred to y, and the subscripts of this element to i and k;
begin
integer p, q;
y := 0; i := k := 1;
for p := 1 step 1 until n do
for q := 1 step 1 until m do
if abs(a[p, q]) > y then
begin y := abs(a[p, q]);
i := p; k := q
end
end AbsmaxIn a sense, since it's compiled, yes... but that depends what you call philosophical. I'll try to explain later.
Interesting read, and I have still to read it all, but I wasn't talking about C pointer arithmetics.
I was talking about the fact that, in processors, you could very early access a memory using two registers that were added (and possibly a x2 or x4 multiplication involved like in x86). Thus it was making sense to put the address of the "table" in one and the index in the second one.
If you put the beginning of the data area in the first register, the second must hold 0 and not 1 so that the designated memory address is the first data of the chunk. So I still think in hardware, arrays are more logically 0-indexed, and that's even before you even create programming languages.
Spoiled Milk
Banned
That's probably true, but what the index actually is and what the instructions are never has to be the same. So as compile time, you could simply have whatever you want and the compiler would auto-decrement the constant in your array accesses anyway. Just as the compiler already does a million things for you.
Like I said, the third option is for the array indices and the emitted instructions to simply be different.
Also, C is not a low level language. It was meant to be a high level one! And it was so good at what it did that it became the new low level. ALGOL, Fortran, et al's goals were not to be fast but to be sane. Besides Lisp, I cannot tell you of another language around the time of C that was actually any slower than C. (And C was relatively slow for a language for some time).
So what this all means is that if C is actually a high level language, you need to make a decision about indexing. And what I posted might have been a good reason for BCPL, which was otherwise quite simple to compile.
Hey, suppose I declare and initialize a variable/pointer in a recursive function, will the value be declared anew each time we recurse?
E.g.
int someRecursiveFunction(int num) {
int fixedValue = 9001 + num;
int acc = 0;
if (num>0) {
acc++;
someRecursiveFunction(num--);
} else {
return acc;
}
Naturally, in this function, when I call someRecursiveFunction(9), I want fixedValue to remain 9010 for the duration of the function call. However, I want acc to update with each recursive call rather than resetting to 0.
Note that fixedValue and acc must be in local scope (so I can't just declare global variables).
E.g.
int someRecursiveFunction(int num) {
int fixedValue = 9001 + num;
int acc = 0;
if (num>0) {
acc++;
someRecursiveFunction(num--);
} else {
return acc;
}
Naturally, in this function, when I call someRecursiveFunction(9), I want fixedValue to remain 9010 for the duration of the function call. However, I want acc to update with each recursive call rather than resetting to 0.
Note that fixedValue and acc must be in local scope (so I can't just declare global variables).
cpp_is_king
Member
Pass acc as an argument.
Code:
int someRecursiveFunction(int num, int acc=0) {
int fixedValue = 9001 + num;
if (num>0) {
return someRecursiveFunction(num--, acc+1);
} else {
return acc;
}I assume this is a hypothetical example, because fixedValue is not actually used for anything.
Yeah, this is a hypothetical example. Also, I can't change the arguments for the function that I'm trying to implement. So passing an accumulator in the recursive function is a no-go.
cpp_is_king
Member
Yeah, this is a hypothetical example. Also, I can't change the arguments for the function that I'm trying to implement. So passing an accumulator in the recursive function is a no-go.
Make a new function.
Code:
int recursiveHelper(int num, int acc) {
int fixedValue = 9001 + num;
if (num>0) {
return recursiveHelper(num--, acc+1);
} else {
return acc;
}
int somRecursiveFunction(int num) {
return recursiveHelper(num, 0);
}Spoiled Milk
Banned
You want the helper function pattern that's common in functional languages. The idea is to not assume the initial value of the accumulator and define a recursive relationship between successive values. Then you initialize it with the original function.Yeah, this is a hypothetical example. Also, I can't change the arguments for the function that I'm trying to implement. So passing an accumulator in the recursive function is a no-go.
Code:
int someRecursiveFunction(int num) {
return someRecursiveFunctionHelper(num, 0);
}
int someRecursiveFunctionHelper(int num, int acc) {
int fixedValue = 9001 + num;
if (num>0) {
return someRecursiveFunction(num--, acc+1);
} else {
return acc;
}As I am a local ML proponent, here is the same code in f#.
Code:
let rec someRecursiveHelper n acc =
if n > 0 then acc
else someRecursiveHelper (n-1) (acc+1)
let someRecursiveFunction n =
someRecursiveHelper n 0It doesn't help at all unless you're programming something that requires linear algebra. But it turns out that modeling many things does require matrices, yes.
And it'll help you in the roundabout sense that abstract math like linear algebra better prepares your mind for CS problems.
I don't think it's relevant to everyday coding but for more theoretical areas (like algorithms or simulations) it's in the basis of everything, so it depends where you're going