mackncheesiest

They are a media/tech company, not a law firm. Why does it matter what an employee wears if they are getting their work done?

IMO, if someone isn't talking in-person to corporate big-wigs in official settings, if they get their work done, they can wear what/look how they want.
 
Also, who are you to judge? It ain't your company.

I'd be curious what level of experience these students will be working with. If it's an introductory digital logic class or something, 48GB of RAM might be fine (still might be tricky if there's, say, the hypervisor and multiple virtual OSes to partition that with among like 20 students), but I've had some designs in non-class-based design work that used upwards of 16GB + ~8 threads (I think the limit for `set_param general.maxThreads` was around 8 for the version of Vivado I was on) just synthesizing/placing-and-routing/compiling/launching a single post-implementation simulation. And that's just for me, one user. Even if, after the simulation launches, usage quickly drops to basically a single thread and frees a ton of that memory back up (much to the disdain of the user who wants results quickly ). I guess with some intelligent job queuing that takes advantage of those characteristics, that wouldn't be a problem.
 
However, I mostly have experience with single computer licenses of ISE/Vivado, so I can't speak much to the operational characteristics of Quartus or the pros/cons of having a dedicated, remote "synthesis server".

I'd be curious what level of experience these students will be working with. If it's an introductory digital logic class or something, 48GB of RAM might be fine (still might be tricky if there's, say, the hypervisor and multiple virtual OSes to partition that with among like 20 students), but I've had some designs in non-class-based design work that used upwards of 16GB + ~8 threads (I think the limit for `set_param general.maxThreads` was around 8 for the version of Vivado I was on) just synthesizing/placing-and-routing/compiling/launching a single post-implementation simulation. And that's just for me, one user. Even if, after the simulation launches, usage quickly drops to basically a single thread and frees a ton of that memory back up (much to the disdain of the user who wants results quickly ). I guess with some intelligent job queuing that takes advantage of those characteristics, that wouldn't be a problem.
 
However, I mostly have experience with single computer licenses of ISE/Vivado, so I can't speak much to the operational characteristics of Quartus or the pros/cons of having a dedicated, remote "synthesis server".

Yup I spoke to him today, and that's what he wanted.

Haven't had the chance to watch it all, so hopefully this isn't brought up later in the talk, but in a similar vein, even the designers themselves are also assuming (hoping?) that the hardware that's fabricated is the same as what was sent to the fab 
 
There was a really interesting paper out of the University of Michigan last year that demonstrated an attack by which a malicious actor adds as little as one gate to a design at fabrication time and uses analog properties of the design along with a sequence of innocuous commands to modify the system state (like the ability to flip a privileged execution bit). The end result was basically undetectable with existing techniques (and so pretty sure they're working on those now).
 
A summary is given from the first paper on this page. Wired has a more in depth article but this gets to the point faster
http://eecs.umich.edu/eecs/about/articles/2016/IEEE-Security-Privacy-papers.html
The actual paper itself
http://eecs.umich.edu/eecs/about/articles/2016/A2_SP_2016.pdf

This.   The fundamental concept of Turing completeness.

And this is why I chuckle anytime I see some "completely open source" computer system or some FOSS diehard going off. Because the hardware itself often times isn't really open source and is just as bad as the proprietary software they want us to get away from.

I just wanted to share this incredibly interesting video I stumbled across.
A presentation by Christopher Domas about the search for undocumented, and thus purposely hidden, instructions in x86 CPU's.
 
Not only the fact that there seems to be lots of hidden stuff on your average x86 is interesting, the clever ways of probing for those instructions are entertaining. (Well, at least I think so)
 

Haven't had the chance to watch it all, so hopefully this isn't brought up later in the talk, but in a similar vein, even the designers themselves are also assuming (hoping?) that the hardware that's fabricated is the same as what was sent to the fab 
 
There was a really interesting paper out of the University of Michigan last year that demonstrated an attack by which a malicious actor adds as little as one gate to a design at fabrication time and uses analog properties of the design along with a sequence of innocuous commands to modify the system state (like the ability to flip a privileged execution bit). The end result was basically undetectable with existing techniques (and so pretty sure they're working on those now).
 
A summary is given from the first paper on this page. Wired has a more in depth article but this gets to the point faster
http://eecs.umich.edu/eecs/about/articles/2016/IEEE-Security-Privacy-papers.html
The actual paper itself
http://eecs.umich.edu/eecs/about/articles/2016/A2_SP_2016.pdf

TL;DR If you want the what without the why:
Single precision floats allow you to represent many (but not all) real numbers between +/- 3.4 * 10^(38) = +/- (1 + (1 - 2^(-23))) * 2^(255 - 127).
Double precision floats allow you to represent many (but not all) real numbers between +/- 1.8 * 10^(308) = +/- (1 + (1 - 2^(-52))) * 2^(2047 - 1024).
 
If you want the why (and I'll admit this is surely too complicated of an answer for the question given):
Single precision floats are represented with 32 bits in the form
x | x x x x x x x x | x x x x x x x x x x x x x x x x x x x x x x x
s |     exponent   |                    mantissa/fractional               |
Where s = sign bit (positive=0 or negative=1)
Exponent = 8 bits that can represent any number between 0 and 255 (0 to 2^(8) - 1).
Mantissa/Fractional = 23 bits that are used to let you represent numbers that aren't exact powers of 2. (the first bit represents 1/2, the second one 1/4, ..., the last 1/2^(23))
 
The way you figure out what number is represented is by doing +/- (1 + 0.f1 f2 f3...f23) * 2^(exponent - 127).
So, for example, 127 = 01111111, so 1.0 is represented as 0 | 0 1 1 1 1 1 1 1 | 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0. You interpret this as +1 * (1 + 0.0) * 2^(127 - 127) = 1.0
Another example: 3.0 is represented as +1 * (1 + 0.5) * 2^(1) = 0 | 1 0 0 0 0 0 0 0 | 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
-7.5 is -1 * (1 + 0.875) * 2^(2) = 1 | 1 0 0 0 0 0 0 1 | 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 
Why subtract 127? 127 is called the bias, and it's so that you can represent numbers less than 1 as well. Otherwise, 1.0 would be the smallest thing you could represent. 
This is also leaving out some cases where the (1 + 0.f1f2...) turns into (0 + 0.f1f2) (called "denormalized numbers"), but that's okay.
 
Double precision floats use exactly the same system but they have 64 bits instead of 32. They add 3 of those to the exponent and 29 to the fractional/mantissa bits.
x | x x x x x x x x x x x | x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x
s |         exponent        |                                                     mantissa/fractional                                                              |
So, you go from your largest exponent being 255 to 2047 = 2^(11) - 1 which greatly expands your range of representable values (both in how large you can get and how close to 0 you can get), and you go from 23 to 52 fractional bits which basically lets you have a lot more decimal point precision if it's needed.
 
Now, this is just how the standard is defined in IEEE_754-1985 (the 2008 additions pretty much just added new formats and left single and double floats alone), and, like Unimportant said, once you get into the actual implementation of this standard on various platforms...
 

I've actually never used Cake either, but I think you might be able to get by with something like
Task("buildEverything").Does(() => { DotNetBuild("myProject.sln", settings => settings.SetConfiguration(configuration).SetPlatformTarget(PlatformTarget.x64)); DotNetBuild("myProject.sln", settings => settings.SetConfiguration(configuration).SetPlatformTarget(PlatformTarget.x86)); ... }); RunTarget("buildEverything") Although I don't think this is exactly right since the PlatformTarget enum doesn't actually have values for all of the builds you would like to do.
 
As a warning, this is mostly based on looking through a few resources/tutorials and piecing them together with this resolved Github issue that deals with setting the platform target in Cake. Along with a basic browsing of the documentation for the DotNetBuild function. So, basically, no clue if this works. Hopefully it helps you in the right direction though.
 
Worst case scenario, you could always also try to take a powershell/cmd scripting "makefile" type approach. If all you want to do is run the same build commands with different platform target arguments and you don't really care about the dependency management or test verification type things that Cake seems to provide, it could end up being easier.

I'm not incredibly experienced with JAXB, but I believe you may be looking for the @XmlAttribute annotation. I think one solution might be something like
@XmlRootElement(name = "Style") public class Style { @XmlElement(name = "IconStyle") private IconStyle iconStyle; @XmlAttribute(name = "id") private String id; ... } I believe that should add an XML attribute to the Style tag (which if I'm interpreting your problem right is what you're looking for), and as long as JAXB's marshalling then properly marshalls the IconStyle tag, I think you'll be good. Also see https://stackoverflow.com/a/7498378

It is called hook and I found this https://stackoverflow.com/questions/2067397/can-i-change-a-users-keyboard-input it looks like what you want to achieve.

As far as it is not android specific question then I think that array of strings with file names and the slider value would be an index of the array, just make sure to check if the value is not out of array's bounds. Then you get a file name from the array by index (value of slider) and play it, so no ifs.

Nobody enters a career being the best. It takes hard work and confidence. 

Currently my career is software development. Though not in the glamorized Silicon Valley life or the grudge of crunch time at a video game development. I've been at it for 8 years or so now (and now I feel old). Here's what I've picked up over the years that I think are useful for those who want to make software development a career.
This applies for jobs in general, but it's more important who you know than what you know. Make connections where you can, either at school, in your circle of friends (if they are in similar fields), at job fairs, or social media like LinkedIn. I was hired on most of the jobs I took because I knew someone who could get my foot in the door. The company I work for literally gets hundreds of thousands of applications in a hiring period for maybe a dozen positions. Connections are what help cut in line and get noticed sooner. And if those connections can vouch for you, even better (but make sure you can actually do what they vouch for) It's important to know how to do something. While job interviews are a lot about trying to see if you'll fit in with the team, it'll be your potential supervisor, leads, and colleagues who want to see how you think. If they see you struggling with a basic problem, then it doesn't matter if you can tell them what a advanced technical thing is. Software development and engineering is about solving problems, not about regurgitating what you can find on Wikipedia. Do you have something to show off? In my case, I had my classes I took at school, then when I got laid off and had to look for another job, it was the accomplishments I did on various projects. Things like development something that the rest of the team uses or assembling something together for a customer demo to win a contract. In your case, even if you have something that you think looks dumb, as long as it's related, show them anyway. It helps your employers figure out how you do things. How quickly can you pick up on something? Do you know how to ask the right questions? You will be looking at someone else's code. You will be diving into things you may have never touched before. For instance, I never touched Python until I was a few years into my first job. But I had to learn it because something needed to be fixed.

It seems to me the fact that a language is compiled or not is too often used as a measure to indicate 'speed'. Ppl seem to rush in to defend languages like Java and Python with comments like "Our language can be compiled too!" or "We have JIT". As if compilation is the sole fact that defines speed and efficiency.
 
I've seen interpreted C programs (yes; that exists too) beat the pants of compiled Python.
The far more important part is the fact that languages like C allow for far more undefined behavior. One might frown and wonder why that would ever be a good thing. It's a good thing for speed and efficiency because it allows for optimizations and less 'hand-holding'.
 
Take the simple fact that accessing a array out of bounds in C results in undefined behavior. The standard simply says "don't do that", and nobody can define in advance what will happen if you do (nasal demons, anyone?). Python, on the other hand, seems to have some IndexError exception when a out of bounds access occurs ? (I'm no Python programmer, feel free to step in, but even so I think you'll get the point I'm trying to make when this is done). 
 
Think about what that means for the implementation. It means each and every array access in Python must be checked for a valid index first, that's the only way one can implement a language that defines out of bounds access, by checking before the access. That is slow, plain and simple, compiled or not. In some tight loops the checking is more work then the actual work that needs to be done.
 
By not defining this situation, C allows the implementer to simply forgo any such checks and just "trust the programmer". And that's a crucial step to runtime speed, as a trade off to some development speed, as you'll probably have some more debugging to do. (Although much can be mitigated with proper tools and procedures).
 
 

Both are equally bad.
You should use mt_rand or mt_srand
Why limit the characters to only those in the array? There's other characters on all keyboards that can be easily typed:
 
 

 
From "!" (0x21) to "~" (0x7E) all characters can be manually entered by keyboard or safely printed on screen or sent through email.
Sure, you may want to avoid similar characters like ' (apostrophe, 0x27) and ` (grave accent, 0x60) but it's no biggie.
 
so you could have:
 
function make_password($length=16) { $code = ''; for ($i=0; $i<$length;$i++) { $character_code = mt_rand( 0x21 , 0x7E ); $code .= chr( $character_code ); } return $code; } But Honestly, a better password would be to pick 5-8 random words from a dictionary and capitalize some letters and add some punctuation or hyphens, exclamations, would make for better passwords. Then make a sha256 or md5 hash of that phrase and store that in the database (hashes are fixed length, good for DB storage)
 
obligatory xkcd
 

 
 
 
 
 

It's not just about collisions, GPU-accelerated password hashing absolutely plows through them, with a Titan X Pascal able to do nearly 40 billion md5 hashes per second. There is absolutely no excuse for using an ineffective hashing algorithm, especially md5. They aren't "good enough" and that is the exact line of thinking the lazy engineers at huge companies use that end up having huge security breaches, like LinkedIn.
 
It takes minimal effort to implement an appropriate hashing algorithm over md5 or any other bad choice. There's literally no excuse to do so. Security is immeasurably important. Don't take shortcuts or be cheap. Too many people think they know better than security experts and try to do their own thing - it always ends in failure. Don't be one of those people. Learn how to do things properly and correctly and stay up-to-date in the subject.

psst
 
https://www.ubnt.com/products/#airmax
 
it's wifi over satellite, 450+Mbps bandwidth over 20KM (~12.5 miles) range

Check out Must-reads for Java Developers: From Beginner to Professional. Couple notes
Head First Java is a little dated now, covering Java 5. Which means it doesn't have the new language features from Java 6, 7 and 8 which was the latest release. That isn't stopping people from continuing to recommend it though (ex 1, 2). They just recommend using other material to cover the newer features. Java, A beginners Guide has been updated to a 6th edition and does include the new features.  
Just keep in mind that you're going to find people for and against any book, even good ones. If the large majority of reviews are positive, it's probably worth considering.
 
Also, remember that no book can cover everything and even good books will leave stuff out or can have weak areas. Learn from multiple sources and always be open to exploring new ways to do things.

and when youve been working for a few years you will apply all of these logic laws without thinking or remembering what they are called

Assuming you have a recent version of windows 10, you can always use the bash terminal in windows.

If I remember correctly, you can use setBounds. i.e.
jframe.setBounds(100, 100, 1024, 768) Combined with setResizable, you can annoy your users by setting a fixed size but make your life of dealing with the Swing layouts much easier