swhipple
> If you use GPG, you can sign your assignment using a detached signature in the following manner:
> gpg -a --detach-sig ASSIGNMENT
> Where ASSIGNMENT is the PDF file(s) as you have received it from us.
> Then simply email the assignment, key ID, and signature file back to us at [email protected]. Please make sure that your key is listed on a public keyserver.
https://www.gnu.org/software/gnulib/manual/html_node/mkstemp...
https://github.com/emacs-mirror/emacs/blob/65eee8392ff95f58f...
The one downside that EPL has is that, unlike MPL (without "Incompatible With Secondary Licenses" notice) or LGPL, it is incompatible with the GPL-family of licenses. It specifies different conditions for providing the source code and has a governing law clause (New York).
It is popular in the Java ecosystem (Eclipse, Clojure, etc).
You could still use Erlang's crashing and supervisor technique, but you would have the additional benefit of using static typing across a distributed system (where each node may or may not have received the upgrade yet).
It could be done without a big lock by splitting into three steps:
1) Push an upgrade that changes the types and adds the conversion functions. The valid type is the union of the old type and the new type. Wait until all nodes complete the upgrade.
2) Push an upgrade that instructs the nodes to convert their data and start using the new types by default. Wait until all nodes complete the upgrade.
3) Push an upgrade that removes the old types and conversion functions.
mboxo? [1] It is a popular text format that cannot be unambiguously parsed.
More generally, most Unix tools' output is also not able to be unambiguously parsed. For example, use gcc to compile a file, then collect the warnings? The regex "^.+:\d+:\d+: warning.*" will be right most of the time, but there's no 'correct' way to parse gcc output (there is not a surjective mapping of output to input).
There are various ways to work around the problem: mboxrd format uses an escape sequence to work around the earlier problem mentioned with mboxo. `ls -l --dired' (GNU) will allow you to parse ls by appending filename byte offsets to the output. `wc --libxo xml` (FreeBSD) will give the output in XML, which is unambiguous as well. multipart/form-data (RFC2388) is used to embed binary data in a text format, by using a byte sequence which doesn't appear in the data.
Binary formats present their own set of issues, but "accidentally unparseable" is more common in text-based formats (or ad-hoc text output).
[1] https://www.nczonline.net/blog/2016/10/the-ecmascript-2016-c...
1) Prevent tampering by making part of the system immutable? The fingerprint isn't necessary; unconditionally prevent modification to the relevant files instead.
2) Prevent tampering by using trusted files? Normally this should be done by having a set of trusted keys, not hardcoded hashes. That way you can still securely upgrade the system.
3) Accessing files from a remote untrusted filesystem? This doesn't seem to work either; see the caveats section in veriexec(9).
Am I missing something here?
In HTML, <script></script> is valid. <script /> is invalid. <br /> is valid. <br></br> is invalid. So they are represented differently.
> Using (:tag/) is a bad idea because that would screw up attributes.
For my example?
((:tag/ :attr "value")) => <tag attr="value" />
((:tag :attr "value") "..." (:/tag)) => <tag attr="value">...</tag>
That sounds like it could work. So a leading `nil' would be treated as a special case (not a child node):
(:pre "
" (:span "one
") "
" (:br) "
" (:span "two") "
" (:br nil) "
")This is why you would need separate tags to emit them properly with an S-expr syntax (tag), (tag/), and (tag)(/tag) in my example.
I believe this is where the confusion is coming from. When you parse HTML syntax, you get a data structure; this is the same as when you read sexpr syntax, you also get a data structure. Both these data structures are different from the DOM tree.
Try this example:
<pre>
<span>one
</span>
<br>
<span>two</span>
<br />
</pre>
Outside of CL-WHO and Hiccup-type libraries, you can of course use S-exprs to represent the same data structure. Here's a hypothetical S-expr syntax that might produce the same data structure:
((pre)
"\n " (span) "one\n " (/span)
"\n " (br)
"\n " (span) "two" (/span)
"\n " (br/) "\n"
(/pre))
> you can't represent all valid HTML documents as S-expressions, at least not in the convenient way people assume
a (b); /* function call or declaration */
a * b; /* multiplication or declaration */
f((a) * b); /* multiplication or deref and cast */
[1] http://eli.thegreenplace.net/2007/11/24/the-context-sensitiv...
Regarding applying backpressure, you're correct that Erlang doesn't have a silver bullet. Process mailboxes are unbounded and can exhaust resources. Or you can implement a buffer and drop messages based on some strategy.
As for making every 'operation' asynchronous, you could do it and not run into any additional unbounded queue or error handling problems, but it would add overhead without any advantage over concurrency via preemption.
> It happened that some modifications and extensions to Reference 1 were agreed to at the experiment kickoff meeting at NSWC. Dr. Jones and Dr. Hudak were not informed of those extensions until after the completion and review of the initial draft of Prototype 1. [...]
> Prototype 2: We believe that our Prototype 2 will be most comparable to the prototypes prepared by the other teams. This prototype satisfies all mandatory requirements of the problem as defined in References 1 and 2, and also incorporates generalizations to support anticipated future requirements. To accomplish this task, the original author of Prototype 1 made a number of modifications and enhancements requiring about five hours [...]
P1 and P3 solutions are attached in appendices, along with some others.
[1] http://www.cs.yale.edu/publications/techreports/tr1031.pdf
re: dynamic scope, I agree that Emacs' future is with lexical-binding for non-special variables. Chris Wellons recently wrote a great post which has shown up on my radar: http://nullprogram.com/blog/2016/12/22/
I'm wondering what you have in mind by user-modifiable systems. For example, KDE and Firefox are free and allow for quite a bit of user-customization without any programming knowledge. At some level you would naturally have to write code.
I recently came across this interview and thought it was well done. Stallman responded to a similar question: https://youtu.be/NB8mCcLRxlg?t=59m55s
It's also worth noting that it is not only Stallman's FSF that uses this definition w.r.t intellectual property nowadays. Lessig's CC adopted the same terminology for their share-alike license (-SA), which has the goal of preserving freedom, while -NC or -ND are considered non-free because they contain restrictions not related to this purpose. The same is true in the greater free-culture community and academic contexts from my experience.
There are plenty of reasons to be anti-DRM or pro-user privacy, but the "it uses numbers" argument is not a particularly good one.
"The sky is blue" is a non-political statement only because no one stands to make money convincing people otherwise.
display (image :type svg :file "splash.svg")
`str' can be interned in some situations, though the rules vary across implementations and versions. Most of these things just boil down to unintuitive caching optimizations. Like you mention, it's pretty rare to check the object identity for integers or strings, but if you are doing so, you probably want the real answer.
Aside Python's small integers, True, False, and None, Java has these rules for boxing in the specification [1]:
> If the value p being boxed is an integer literal of type int between -128 and 127 inclusive (§3.10.1), or the boolean literal true or false (§3.10.3), or a character literal between '\u0000' and '\u007f' inclusive (§3.10.4), then let a and b be the results of any two boxing conversions of p. It is always the case that a == b.
> Ideally, boxing a primitive value would always yield an identical reference. In practice, this may not be feasible using existing implementation techniques. The rule above is a pragmatic compromise, requiring that certain common values always be boxed into indistinguishable objects. The implementation may cache these, lazily or eagerly. For other values, the rule disallows any assumptions about the identity of the boxed values on the programmer's part
[1] http://docs.oracle.com/javase/specs/jls/se8/html/jls-5.html#...
Open source is about collaboratively building tools for developers and businesses, or simply because collaboration produces better software. The software is often released under permissive terms. Apple participates in open source projects.
Free software is focused on the end user having freedom over their software by ensuring that they have the ability to read, modify, and redistribute it. Apple does not give these rights to users of their platforms.
The post that was linked was the FSF, which argues from the free software perspective.
A terminal emulator and a child process will have different virtual address spaces, so you may choose that as the discriminating factor. A web browser and a web application will share address space. But a web browser and a web application are clearly two separate programs as well.
It isn't really a problem unique to the GPL. Any interpretation of a non-trivial license with conditions will have an element of "I know it when I see it". Software licenses especially due to the level of abstraction.
The GPLv3 applies to the Program as the GPL defines it. It has a provision, in Section 5, for aggregate works of many programs and is mentioned in the FAQ [1].
> But some argue even typing a file name into a terminal window constitutes a dynamic link.
Who? The FSF holds the opposite. A terminal emulator and a program that runs within it are two separate programs.
[1] https://www.gnu.org/licenses/gpl-faq.en.html#MereAggregation