Password is visible in online sign up form

I am about to sign up for an online school, which is an accredited statewide online school, and notice that the password they want me to enter is fully visible on the form. Should I be concern about their information security? Does a form like this indicates that the way the way the school protects students’ data is not secure, such as storing password verbatim rather than something like one-way hash?

If such forms violate established data security practices, what document(s) should I refer to the school’s IT people regarding that?

Online sign-up form

Datfortress’s programs are always visible in their cells, or triggered only when Netrunner pass by their cell?

In all the samples of Netmap, we can see data fortress with walls, gates, CPUs, memories, and also programs in a determined cell.

Now I wonder, when the netrunner enters in the subgrid and starts to attack the fortress, does he see the program in a far cell (if visibility is not blocked by an obstacle and withing 20 spaces)? Or the map that the netrunner sees, doesn’t show the location of programs and will be the referee to decide when a program appear in that determined cell, probably triggered by the netrunner or other programs passing by that cell?

Also, not all programs have "endurance", and they should be deactivated at the end of their action at the end of the turn, so how is possible that Datafortress has all its programs always activated?

So this makes me think that programs are "preassigned" to a cell, but they are like in a sleeping mode, and only after triggering they appear doing their action. Can somebody explain how you did in your netrunner mini-games?

Is a Sorcerer’s Flexible Casting visible?

Is there any RAW regarding what it looks like when a sorcerer is burning a spell slot into sorcery points? Is there any way to detect it? I’m thinking about a sorcerer in a social situation who uses subtle spell a lot to cast sneakily, and runs out of sorcery points and needs to make more while still being observed. Can they create more spell points without alerting the observers to the fact that they’re doing something magical?

WordPress Plugin to display a list of input fields which are visible to everyone?

I am looking for a plugin/workaround recommendations. I am sorry if the title was not descriptive enough, this is the best I could think of. Any edit suggestion is welcome.

I want to display a list of editable text fields, which are updated by any visitor, and all updates are live and public to everyone else. The submitted fields may or may not be editable anymore.

So, once a visitor visits the page, there will be a list of empty blanks/fields, short text fields for instance. They will fill in their name and their details, then submit. All other visitors will see that this field is taken/filled.

The reason is that there will be a list of offerings, and the link will be distributed among participants only, each participant can fill a “slot” with their details after seeing which slots are available.

I don’t need any extra validation or complexity. Logging in is not required.

  • Preferably free, reasonably paid solutions are accepted, too.

Home page only visible for some viewers

we created a website for a client. When we enter the URL, it loads to the home page no problem for us and several other testers, but a bunch of other users are reporting getting the old holding page. Those users can see all the other pages on the website, but not the home page. url: Any clues? We’ve tried getting them to clear caches and use different search engines but all they’re getting is a contact form instead of the correct home page.

Why are DNS requests visible with DNS over HTTPS enabled?

So, Firefox 73 rolled out today and with it comes a new DNS option called NextDNS. I thought of giving it a shot and clicked “Enable DNS over HTTPS” and selected NextDNS.

Now, my understanding of HTTPS is that it encrypts the traffic (to provide confidentiality) and prevents tampering (to check integrity). But, when I started snooping on my own traffic using tcpdump, I found entries such as these:

root@Sierra ~ % tcpdump dst port 53  00:16:18.598111 IP > 15871+ A? (42) 00:16:18.601087 IP > 44174+ A? (35) 00:16:18.602982 IP > 63750+ AAAA? (42) 00:16:18.855488 IP > 7245+ A? (29) 00:16:18.855976 IP > 17221+ A? (29) 00:16:18.855998 IP > 24136+ AAAA? (29) 00:16:18.856830 IP > 52531+ A? (42) 00:16:24.097262 IP > 38286+ A? (29) 00:16:24.097448 IP > 44461+ AAAA? (29) 00:16:24.451349 IP > 60808+ A? (33) 00:16:24.456921 IP > 6906+ A? (33) 00:16:29.106318 IP > 54705+ AAAA? (29) 00:16:33.269314 IP > 3958+ A? (29) 00:16:42.515778 IP > 33887+ A? (62) 00:16:42.516330 IP > 62418+ A? (42) 00:16:42.889225 IP > 41105+ A? (62) 00:16:43.453717 IP > 44380+ A? (47) 

Apparently, this doesn’t look encrypted. When I changed my DNS server to Cloudflare, I could only see the entries for Cloudflare’s DNS server (which is what I expect from DoH). So, what’s wrong with NextDNS? How is NextDNS different from unencrypted DNS? And, am I missing something here?

Color contrast too low, but element good visible

I am checking a software against the software ergonomic requirements of WCAG 2.1 Level AA. On part is the colour contrast, which must be for graphics 3.0:1. In the following graphic the orange part is for users without any disabilities very good visible, however the tool “Color Contrast Analyser” show only a contrast to the white background of 2.0:1.

So the graphic does not meet WCAG 2.1 Level AA. But what is the reason? Again: the orange part of the graphic is very good visible. Might it be an inaccuracy of algorithm for calculating colour contrast? Or is it just my personal sensation?

Any other ideas?

graphic with red, orange and green skala. medium value is 38.

Is the choice of static and dynamic typing not visible to the programmers of the languages?

From Design Concepts in Programming Languages by Turbak

Although some dynamically typed languages have simple type markers (e.g., Perl variable names begin with a character that indicates the type of value: $ for scalar values, @ for array values, and % for hash values (key/value pairs)), dynamically typed languages typically have no explicit type annotations.

The converse is true in statically typed languages, where explicit type annotations are the norm. Most languages descended from Algol 68 , such as Ada , C / C++ , Java , and Pascal , require that types be explicitly declared for all variables, all data-structure components, and all function/procedure/method parameters and return values. However, some languages (e.g., ML , Haskell , FX , Miranda ) achieve static typing without explicit type declarations via a technique called type reconstruction or type inference.

Question 1: For dynamically typed languages which “have no explicit type annotations”, do they need to infer/reconstruct the types/classes, by using some type/class reconstruction or type/class inference techniques, as statically typed languages do?

Question 2: The above quote says static or dynamic typing and explicit or no type annotations can mix and match.

  • Is the choice between static and dynamic typing only internal to the implementations of programming languages, not visible to the programmers of the languages?

  • Do programmers in programming languages only notice whether the languages use explicit type/class annotations or not, not whether the languages use static or dynamic typing? Specifically, do languages with explicit type/class annotations look the same to programmers, regardless of whether they are static or dynamic typing? Do languages without explicit type/class annotations look the same to programmers, regardless of whether they are static or dynamic typing?

Question 3: If you can understand the following quote from Practical Foundation of Programming Languages by Harper (a preview version is,

  • Do the syntax for numeral (abstract syntax num[n] or concrete syntax overline{n}) and abstraction (abstract syntax fun(x.d) or concrete syntax λ(x)d ) use explicit types/classes with dynamic typing?
  • If yes, is the purpose of using explicit types/classes to avoid type inference/reconstruction?

Section 22.1 Dynamically Typed PCF

To illustrate dynamic typing, we formulate a dynamically typed version of PCF, called DPCF. The abstract syntax of DPCF is given by the following grammar:

Exp d :: = x x variable            num[n] overline{n}      numeral            zero zero      zero            succ(d) succ(d)      successor            ifz {d0; x.d1} (d) ifz d {zero → d0 | succ(x) → d1}      zero test            fun(x.d) λ(x)d      abstraction            ap(d1; d2) d1 (d2)      application            fix(x.d) fix x is d      recursion 

There are two classes of values in DPCF, the numbers, which have the form num[n], and the functions, which have the form fun(x.d). The expressions zero and succ(d) are not themselves values, but rather are constructors that evaluate to values. General recursion is definable using a fixed point combinator but is taken as primitive here to simplify the analysis of the dynamics in Section 22.3.

As usual, the abstract syntax of DPCF is what matters, but we use the concrete syntax to improve readability. However, notational conveniences can obscure important details, such as the tagging of values with their class and the checking of these tags at run-time. For example, the concrete syntax for a number, overline{n}, suggests a “bare” representation, the abstract syntax reveals that the number is labeled with the class num to distinguish it from a function. Correspondingly, the concrete syntax for a function is λ (x) d, but its abstract syntax, fun(x.d), shows that it also sports a class label. The class labels are required to ensure safety by run-time checking, and must not be overlooked when comparing static with dynamic languages.