Blue Bottle Das von Heinrich Caro im Jahr 1876 erstmals hergestellte Methylenblau (3,7-Bis(dimethylamino)-phenothiaziniumchlorid, N,N,N',N'-Tetramethylthioniumchlorid, Methylthioniumchlorid) ist der wichtigste Vertreter der kationischen Phenothiazin-Farbstoffe (Thiazin-Farbstoffe). Als reiner Farbstoff erscheint Methylenblau als dunkelgr�nes Pulver, bzw. in Form dunkelgr�ner Kristalle. Das meist gehandelte Zinkchlorid-Doppelsalz des Methylenblaus ist ein braunes, metallgl�nzendes, kristallines Pulver. Methylenblau wird als Redoxindikator benutzt. Es ist ein guter Wasserstoff-Akzeptor, der Alkohole in Gegenwart von Platin zu Aldehyden oxidiert und dabei entf�rbt wird. Dieser Versuch l�sst sich auch mit Glucose und Luftsauerstoff als "Blue-Bottle-Experiment" durchf�hren. Methylenblau f�rbt die mit Tannin gebeizte Baumwolle ziemlich echt blau. �berraschend hohe Lichtechtheit zeigen mit Methylenblau gef�rbte Polyacrylnitril-Fasern, weshalb es bis in neuere Zeit zum F�rben und Drucken, auch von Papieren, kosmetischen Artikel, als Lackfarbstoff sowie in der Medizin und Mikroskopie verwendet wird. In der Histologie wird es zuerst durch Paul Ehrlich zur F�rbung bestimmter Gewebearten (besonders Nerven) verwendet. Weiterhin wurde Methylenblau fr�her als Antiseptikum bei Malaria und Allgemeininfektionen, als Antirheumatikum und zu Diagnosezwecken eingesetzt. Methylenblau diente �brigens lange Zeit in der biochemischen Forschung als Modellsubstanz f�r NAD . Im Gemisch mit Methylrot dient Methylenblau als Mischindikator. [1] Es handelt sich bei der Blue-Bottle-Reaktion um eine durch Methylenblau katalysierte Oxidation der Glucose. Oxidationsmittel ist der Luftsauerstoff. Methylenblau bildet dabei in reversibler Reaktion eine farblose Leukoform (Leukomethylenblau), in der das vorher vorhandene chinoide, mesomerie-stabilisierte System des Methylenblaus unterbrochen ist. Die farblose Stufe des Leukomethylenblaus kann als Beispiel f�r eine aktive �bergangsverbindung eines Katalysators angesehen werden. Bei der Oxidation von Glucose wird der Sauerstoff nicht durch den Luftsauerstoff, sondern durch Reaktion mit Wasser eingef�gt. Dabei entstehen formal Protonen, die eine weitere Reaktion verhindern w�rden. Entsprechend werden die Protonen mit der Lauge abgefangen. D-Glucose geht in der vorliegenden alkalischen Natriumhydroxid-L�sung zu Gluconat �ber. Beim Sch�tteln der Fl�ssigkeit gelangt Sauerstoff aus der Luft in die L�sung, der das Leukomethylenblau wieder zu Methylenblau oxidiert. Beim Stehen lassen beginnt die Reduktion des Methylenblaus erneut. Der Zeitpunkt, bei dem die durch Sch�tteln hervorgerufene Farbe wieder verschwindet, ist von der NaOH-Konzentration abh�ngig. Bei hoher NaOH-Konzentration erfolgt der Farbumschlag von blau nach farblos schneller, bei niedriger Konzentration langsamer. | |
Vorg�nge beim Sch�tteln - Falbe, J., Regitz, M.: R�mpp Chemie Lexikon, 9. Aufl., Georg Thieme Verlag, Stuttgart, New York, 1991, S. 2749
- http://dc2.uni-bielefeld.de/dc2/katalyse/bluebott.htm , Stand 27.01.06
- http://ch10.tiho-hannover.de/chemie/OrgPrak/OrgPrak5Ueb.htm#9.%20Oxidation% 20und%20Reduktion%20von%20Methylenblau , Stand 27.01.06
� Walter.Wagner �t uni-bayreuth.de, Stand: 20.09.10 Blue Bottle (Blaues Wunder) Experiment: Versuch: Blue Bottle-Versuch (Blaues Wunder) Es handelt sich bei der Blue Bottle-Reaktion um eine durch Methylenblau (Mb + ) katalysierte Oxidation der Glucose. Oxidationsmittel ist letztlich der Luftsauerstoff. Die Mitwirkung des Methylenblaus erkennt man an seiner Entf�rbung. Die farblose Stufe MbH kann als Beispiel f�r eine aktive �bergangsverbindung eines Katalysators angesehen werden. Methylenblau diente �brigens lange Zeit in der biochemischen Forschung als Modellsubstanz f�r NAD + . Wof�r ist beim Experiment das alkalische Milieu n�tig? Bei der Oxidation von Glucose wird der Sauerstoff nicht durch Luftsauerstoff, sondern durch Reaktion mit Wasser eingef�gt. Dabei entstehen formal Protonen, die die weitere Reaktion verhindern. Die Protonen f�ngt man mit der Lauge ab. Damit verschiebt man das Oxidationsgleichgewicht der Glucose in Richtung auf das Produkt. Weitere Texte zum Thema �Katalyse� Diese Seite ist Teil eines gro�en Webseitenangebots mit weiteren Texten und Experimentiervorschriften auf Prof. Blumes Bildungsserver f�r Chemie. Letzte �berarbeitung: 29. Mai 2014, Dagmar Wiechoczek Physical Science - Social Science
- Medical Science
- Mathematics
- Paleontology
The Blue Bottle Experiment ExplainedThe famous blue bottle experiment a visually dramatic way to teach reduction-oxidation (redox) chemistry. Students from grade school to grad school find this reaction memorable and it is considered a classic staple in chemical demonstration shows. A half-full bottle of colorless liquid turns blue when shaken, and when the bottle is allowed to sit still, the color fades. Shaking the bottle again causes the color to reappear like magic! What’s going on? On the molecular level, the blue bottle experiment is a complex system composed of ethanol, the simple sugar glucose, the dye methylene blue, the hydroxide ion, and oxygen from the atmosphere. The color change occurs do to a pair of competing reduction-oxidation reactions. Hence, the blue bottle experiment is a wonderful tool for introducing the key concepts of reduction and oxidation. All redox reactions involve electrons being transferred from one compound, the reducing agent, to another compound, the oxidizing agent. The term “reduction” means “gain of electrons”. This seems like an odd choice of terminology since “gain” and “reduce” are usually considered antonyms. However, because the electron has an electrical charge of negative one, gaining electrons will reduce the charge of a species. The term “oxidation” means “loss of electrons” and often, but not always, involves reaction with oxygen. A common mnemonic is the phrase OIL RIG, which stands for “Oxidation Is Loss, Reduction Is Gain”. In first stage of the blue bottle experiment, the methylene blue dye acts an oxidizing agent and the glucose acts as a reducing agent. The methylene blue oxidizes the glucose to gluconic acid and the glucose reduces the methylene blue to its colorless form. The result is a bottle of colorless solution. When the bottle is shaken, the surface are of the liquid temporarily increases, causing more oxygen to dissolve in the ethanol. The additional oxygen acts as an oxidizing agent and changes methylene blue to its blue, oxidized form. The result is a dramatic color change from colorless to blue. When the shaking is stopped, the oxygen levels in solution begin to drop. With less oxygen present, the methylene blue once again is reduced to its colorless form by the glucose, and observers will see the color fade and disappear. The color change can be repeated many times simply by shaking the bottle to induce the blue color and then allowing it to sit still in order to make it disappear. Related posts: | | ( ) | | 1200 points by | | | | | | |
| | | | | | be compatible with newer versions of TypeScript.Ask me how I know. ;) | | | | | | has been relatively stable for more versions of Typescript than it was unstable. You had to reach all the way back to 1.5 in part because it's been very stable since about 2.x. The last major shift in syntax was probably Conditional Types in 2.8 adding the ternary if operator in type positions. (The type if you were to try to typecheck rather than just type-strip has changed a lot since 2.x, but syntax has been generally stable. That's where most of Typescript's innovation has been in the type model/type inferencing rather than in syntax.)It's still just (early in the process) Stage 1, but the majority of Typescript's type syntax, for the purposes of type stripping (not type checking), attempting to be somewhat standardized: | | | | | | add a new keyword, satisfies, in 5.4. That would be a breaking change if you can’t upgrade the type stripper separately. | | | | | | (I think not using `as` is a better fit semantically but this could be a trade-off to make for better type stripping backwards compatibility) | | | | | | Any solution I can come up with suffers from at least one of these issues:- "ignore rest of line" will either fail or lead to incorrect results - "find matching parenthesis" would have to parse comments inside types (probably doable, but could break with future TS additions) - "try finding end of non-JS code" will inevitably trip up in some situations, and can get very expensive I'd love a rough outline or links/pointers, if you can find the time! [0] TS Playground link: | | | | | | | Without knowing about the new wobble syntax this would be parsed as `x as wobble; T` and desugar to `x; T`With the new wobble syntax it would be parsed as `x as (wobble T);` according to JS semicolon insertion rules because the expression wobble is incomplete, and desugar to `x` | | | | | | Here T is “a”|”b”, no automatic semicolon is inserted after `keyof`. While I don’t personally write code like this, I’m sure that does. It’s perfectly within the rules, after all.While it’s true that TS doesn’t have to follow JS rules for semicolon insertion in type expressions, it always has done, and probably always should do. | | | | | | | do is stabilize the grammar, and release new versions of TypeScript using the same grammar. Maybe you need a flag to use LTS grammar in your tsconfig.json file. | | | | | | too easily -- it puts everyone who uses it on an upgrade treadmill, so it should be done judiciously. But even I wouldn't argue that TS 1 should have been its final form. | | | | | | take a type parameter.True, but TypeScript has a rule against type-dependent emit - it’s not allowed. Code must always do the same thing regardless of what the types are. And in any case JavaScript does allow indexing on functions, since functions are just objects. | | | | | | ): Could you explain how this isn't the type system accepting types "different to what has been declared"? Kinda looks like TypeScript is happy to type check this, despite `s` being a `number` at runtime. | | | | | | , and TypeScript very intentionally documents that they do this and are just trying to make a "best effort" pass because JavaScript has 0 types, and crappy types are better than no types, and we can't wait for perfect types to replace the crappy types. | | | | | | | way whatsoever), an exception is thrown. See This is very much the same thing (or remotely analogous) to what we have in my TypeScript example. There, the code fails at runtime when I attempt to call `toLowerCase`, yes; what's worse is the slightly different scenario where we succeed in calling something we shouldn't: It is not possible to write an analogous example in Haskell using `head`. | | | | | | so that they could compile Flutter apps AOT. This didn't require anyone to make their code resemble what you'd do in a theorem prover — it just means that, for example, all casts are checked, so that they throw if the value doesn't turn out to have the type the cast wants to return.TypeScript is unsound because when you have an expression with a type, that tells you nothing at all for sure about what the value of the expression can be — it might be of that type, or it might be anything else. It's still valuable because you can maintain a codebase where the types are accurate, and that's enough to help a lot in reading and maintaining the code. | | | | | | | a statement about the (static) type system in isolation: it’s tied to the language’s dynamic semantics.The tricky part, of course, is defining “type error”. In theoretical contexts, it’s common to just not define any evaluation rules at all for outwardly ill-typed things (negating a list, say), thus the common phrasing that no well-typed program must get stuck (unable to evaluate further). In practical statically-typed languages, there are on occasion cases that are defined not to be type errors essentially by fiat, such as null pointer accesses in Java, or escape hatches, such as unsafeCoerce in practical implementations of Haskell. Of course, ECMAScript just defines behaviour for (except violating invariants in proxy handlers, in which case, lol, good luck), so arguably every static type system for it is sound, even one that allows var foo: string = 42. Obviously that’s not a helpful point of view. I think it’s reasonable to say that whatever we count as erroneous situations must at the very least include all occurrences of ReferenceError and TypeError. TypeScript prevents most of them, which is good enough for its linting use case, when the worst possible result is that a buggy program crashes. It would definitely not be good enough for Closure Compiler’s minification use case, when the worst possible result is that a correct program gets silently miscompiled (misminified?). [1] | | | | | | I wonder how widely used that option is. As I said in that other comment, it feels to me like the sort of thing that would produce errors all over the place, and would therefore be a real pain to migrate to. (It'd be just fine if the language semantics were that out-of-bounds array access throws, but that's not the semantics JS has.) I don't have a real empirical sense of that, though. | | | | | | | has worked for me, but it might affect library objects or browser built-ins that I definitely don't want it to, but I've not gotten the version of it to work. | | | | | | | within a more modern codebase! | | | | | | I happen to know this because we have some old projects that depend on this and are working hard to get rid of the dependency. I wish Google either updates it or just mark the whole thing deprecated -- the world has already moved on anyway. Relating this to Google's recent cost cutting, and seeing some other Google's open source projects more or less getting abandoned, I have to say that today's Google is definitely not the same company from two decades ago. | | | | | | There was: (2013). Summary: / | | | | | | | easy to get started with back in the day. It allows for incremental correctness, has good docs, and good tooling. On top of that a lot of beginner React tutorials started out with TypeScript, which onboarded a lot of new engineers to the TS ecosystem, and got them used to the niceties of TS (e.g. import syntax). | | | | | | For me, typescript is a pretty good balance. | | | | | | but if you read the whole section, it ends up also acknowledging that it's not entirely sound. | | | | | | | Compare these two programs. | | | | | | to be `undefined`. The throw only happens later when the value is treated as the wrong type.I don't consider a runtime error to be a failure of the type system for OOB array access. But in javascript, it's explicitly allowed by specification. It's a failure of any type system that fails to account for this specified behavior in the language. | | | | | | > It's a failure of any type system that fails to account for this specified behavior in the language.Haskell has the ability to handle the error. How do you recommend a compiler to detect out-of-bounds at compile time? It can certainly do this for our trivial example, but that example will also be immediately evident the first time you run the code too, so it's probably not worth the effort. What about the infinite number of more subtle variants? | | | | | | | Soundness is valuable because it makes it possible to look at the types and reason about the program using them. An unsound type-checker like TypeScript or Flow can still be very useful to human readers if of the types in a codebase are accurate, but you always have to keep that asterisk in the back of your head. One very concrete consequence of soundness that it makes it possible to compile the code to fast native code. That's what motivated Dart a few years ago to migrate from an unsound type system to a sound one: so that it could AOT-compile Flutter apps for speed. | | | | | | to do so and import it in JSDoc, but as mentioned before it’s a huge PITA on top of the PITA that writing types can already be (e.g. function/callbacks/generics) | | | | | | Ah yes, autocomplete is another benefit of machine-readable type hints. OTOH there's an argument that another IDE feature, informational pop-ups, would be better if they paid more attention to comments and less to type hints: | | | | | | I think this should be part of the language spec. | | | | | | | making Typescript official.They just can't have browsers doing the actual type checking because there isn't a specification for how to do that, and writing one would be extremely complicated, and I'm not sure what the point would be anyway. | | | | | | types.I agree - but the type systems of both Python and TypeScript are unsound, so all type hints can potentially be wrong. That's one reason why I still mostly use untyped Python - I don't think it's worth the effort of writing type annotations if they're just going to sit there and tell lies. Or maybe the unsoundness is just a theoretical issue - are incorrect type hints much of a problem in practice? | | | | | | necessarily abide the semantics of the language: `strings` is declared as a `Array<string>`, but TypeScript is happy to insert a `number` into it. This is a contradiction, and an example of unsoundness. `s` is declared as `string`, but TypeScript is happy to assign a `number` to it. This is a contradiction, and an example of unsoundness. This code eventually fails at runtime when we try to call `s.toLowerCase()`, as `number` has no such function. What we're seeing here is that TypeScript will readily accept programs which violate its own rules. Any language that does this, whether nominally typed or structurally typed, is unsound. | | | | | | add the new properties. That's just a good practice in the general case: an intermediate type that fully described the data wouldn't have saved you from overwriting it unless you actually looked closely at the type signature.And yes, TypeScript types are "at least these properties" and not "exactly these properties". That is by design and is frankly one reason why I TypeScript over Java/C#/Kotlin. I'd be very interested to know what you'd do to change the type system here to catch this. Are you proposing that types be exact bounds rather than lower bounds on what an object contains? | | | | | | . An intermediate type signature with `updatedAt` as a key will produce a type error regardless of the type of the corresponding value.> I'd be very interested to know what you'd do to change the type system here to catch this. Like the other commenter said, extensible records. Ideally extensible types, with records, unions, heterogeneous lists, and so on as interpretations, but that seems very unlikely. | | | | | | | But once you’re aware of the caveat it’s something you can deal with, and it certainly doesn’t negate the many massive benefits that TS confers over vanilla JS. | | | | | | | Or, given there's no need for the type hints to be checker-friendly, do you make them more human-friendly, e.g: | | | | | | Yeah, until this discussion I thought the main benefit of type hints was earlier detection of bugs via static checking. Now though, I'm getting the impression that the bigger benefit is enabling IDE features such as autocomplete. That helps me understand better why I haven't found type hints as useful as others seem to - I don't use an IDE. My use of Python is limited to small scripts which I write in a simple text editor. | | | | | would very much prefer if NPM modules that have their original code in TS and are currently transpiling would stop shipping dist/ .ts files we could just remove those transpiling steps without ever noticing it... so what's stopping NPM publishers from publishing js/d.ts files without noticing they broke anything? | | | | | | > I'm not sure I follow you there. I did continue shipping ESM. > Oh, I didn't know about that, cool! Once it becomes un-flagged I might consider dropping CJS. | | | | | | | also never intentionally written anything directly in CJS. I learned enough in the AMD days to avoid CJS like a plague.) | | | | | | > It might seem like a small amount of work, but for a library one must to multiply that small amount of work by the number of users who will have to repeat it. It can be a quite large amount in aggregate. And, for what benefit? So I can drop one line from my CI config? It just seems like a huge waste of everyone's time. Also, as a library user, I would (and occasionally do) get annoyed by seemingly unnecessary work foisted on my by a library author. It makes me consider whether or not I want to actually depend on that library, and sometimes the answer is no. | | | | | Which is basically reinventing what typescript is already doing. | | | | | | I believe modular implicits and modular typeclasses are similar and aim to solve the same issues, but they are not quite the same. | | | | | | Looks reasonably typical, but when we use it: As you can see, getting bad performance is shockingly easy and if these calls were across five different files, they look similar enough that you'd have a hard time realizing things were slow. Union/intersection aren't directly evil. Unions of a single type (eg, a union of strings) is actually great as it offers more specificity while not increasing function complexity. Even if they are a union of different primitive types, that is sometimes necessary and the cost you are paying is visible (though most JS devs are oblivious to the cost). Optionals are somewhat more evil because they somewhat hide the price you are paying. [key:string] is potentially evil. If you are using it as a kind of `any`, then it is probably evil, but if you are using it to indicate a map of strings to a type, then it's perfectly fine. keyof is great for narrowing the possible until you start passing those keys around the type system. Template unions are also great for pumping out a giant string enum (though there is a definite people issue of making sure you're only allowing what you want to allow), but if they get passed around the type system for use, they are probably evil. Interface merging is evil. It allows your interface to spread across multiple places making it hard to follow and even harder to decide if it will make your code slow. Overloads are evil. They pretend you have two different functions, but then just union everything together. Conditional types are evil. They only exist for creating even more complex types and those types are basically guaranteed to be both impossible to fully understand and allow very slow code. Mapped types are evil. As with conditional types, they exist to make complex an incomprehensible types that allow slow code. Generics are the mother of all that is evil in TS. When you use a generic, you are allowing basically anything to be inserted which means your type is instantly megamorphic. If a piece of code uses generics, you should simply assume it is as slow as possible. As an aside, overloads were a missed opportunity. In theory, TS could speed everything up by dynamically generating all those different function variants at compile time. In practice, the widespread use of generic everything means your 5mb of code would instantly bloat into 5gb of code. Overloads would be a great syntax to specify that you care enough about the performance of that specific function that you want to make multiple versions and link to the right one at compile time. Libraries like React that make most of their user-facing functions megamorphic could probably see a decent performance boost from this in projects that used TS (they already try to do this manually by using the megamorphic function to dispatch to a bunch of monomorphic functions). | | | | | | the runtime code will see that just as a plain string. | | | | | be required. It's not possible to do path searches over the network like you can on local disk, and network-attached VMs, like browsers, are a very, very important runtime for JavaScript. | | | | | | than all-or-none bundles can, sure the trade-off is network requests but we are in a good place to take that trade-off), we're at an exciting point where there is almost never a need to bundle in development environments, and it is increasingly an option to not bundle in production either. It is benchmarking today (I can't tell you what your profiler tools will tell you) if you are really gaining as much from production bundles as you think you are. Not enough people are running those benchmarks, but some of them may already be surprised.The Developer Experience of unbundled ESM is . Of course you do need to do things like always use file extensions. But those aren't hard changes to make, worth it for the better Developer Experience, and if it can help us start to wean off of mega-bundler tools as required production compile time steps. | | | |
IMAGES
VIDEO
COMMENTS
Reaktionsmechanismus der Blue-Bottle-Reaktion: 1. Reduktion von Methylenblau zu Leukomethylenblau: 2. Oxidation der Glucose: 3 Reoxidation des Leukomethylenblau durch den Luftsauerstoff: Entsorgung: Die Reaktionslösung als anorganische, halogenfreie Lösungsmi ttel-Abfälle entsorgen. 2 H.
The blue bottle experiment is a color-changing redox chemical reaction. An aqueous solution containing glucose, sodium hydroxide, methylene blue is prepared in a closed bottle containing some air. Upon standing, it spontaneously turns from blue to colorless due to reduction of methylene blue by the alkaline glucose solution. However, shaking ...
Before the demonstration. Less than 20 minutes beforehand, preferably. Make a solution of 0.05 g of methylene blue in 50 cm 3 of ethanol (0.1%). Weigh 8 g of potassium hydroxide into the 1 dm 3 conical flask. Add 300 cm 3 of water and 10 g of glucose and swirl until the solids are dissolved. Add 5 cm 3 of the methylene blue solution.
blau wird zu einer farblosen Leukoform reduziert. Wird die Lösung geschüttelt, reagiert das Leuko-Methylenblau mit dem in der Lösung gelösten Luftsauerstoff und übertr. gt die Protonen darauf, so dass Wasser entsteht. Methylenblau befindet sich nun wieder im Ausgangszustand u. nsschema des Blue Bottle-ExperimentesEntsorgung:Die Lösung.
The reaction starts as a blue liquid which becomes colorless and returns to its blue color. Materials. The usual materials for the Blue Bottle chem demo are: 8 grams potassium hydroxide (KOH) 10 grams dextrose; Methylene blue solution (0.25 g methylene blue in 1000 mL water) Water; 500-mL flask with stopper; You can make substitutions for the ...
Blue-Bottle-Experiment. Unter dem Blue-Bottle-Experiment versteht man ein klassisches Schauexperiment der Chemie. In einem geschlossenen Gefäß befindet sich eine farblose Flüssigkeit und etwas Luft. ... Die Reaktion zur Entfärbung beruht auf der Reduktion einer Methylenblau-Lösung zur Leuko-Form durch Glucose, die dabei zu Gluconsäure ...
Procedure. 1) Give the colorless solution in the flask a few quick shakes, until a color change is visible. 2) The blue color that appears will then slowly fade. The time required for the color to fade depends on how much the flask is shaken. 3) The regeneration and fading of the blue color may be repeated a number of times by shaking the flask ...
The Blue-Bottle Experiment. Description: A bottle half-full of a colorless liquid is shaken and turns blue. On standing undisturbed, the blue color fades. The cycle may be repeated several times. Other colors can be produced by substituting other indicators for the methylene blue commonly used. Rating: Source: Shakhashiri, B.Z. Chemical ...
Performing the Blue Bottle Demonstration. Half-fill two one-liter Erlenmeyer flasks with tap water. Dissolve 2.5 g of glucose in one of the flasks (flask A) and 5 g of glucose in the other flask (flask B). Add ~1 ml of 0.1% methylene blue to each flask. Stopper the flasks and shake them to dissolve the dye.
A) Experiment with glucose, NaOH, and methylene blue. Add 50 mL of water to the glass flask or beaker. Add 1 teaspoon of glucose powder to the water and stir with a stirring rod until the glucose is dissolved. Add 2 mL of methylene blue solution to the flask or beaker and stir. The solution should turn blue.
Unter dem Blue-Bottle-Experiment versteht man ein klassisches Schauexperiment der Chemie. In einem geschlossenen Gefäß befindet sich eine farblose Flüssigkeit und etwas Luft. ... (Reaktion 1. Ordnung). Reaktion. Die Reaktion zur Entfärbung beruht auf der Reduktion einer Methylenblau-Lösung zur Leuko-Form durch Glucose, die dabei zu ...
The blue bottle reaction is a simple demonstration of a redox reaction, with obvious colour changes. It can also be used as an introduction to reaction kinetics, including the role of temperature on rate of reaction.This procedure details how to perform the eponymous blue bottle reaction, and how different colour changes can be achieved.
Blue Bottle Einleitung. Methylenblau wird mit einer Glucoselösung reduziert und in die farblose Leukoform überführt. Die Leukomethylenblau-Lösung wird mit Sauerstoff versetzt und geschüttelt, wobei der Farbstoff wieder oxidiert wird. ... Redox-Reaktion Experimente mit Reduktions- und Oxidationsvorgang; Sprengstoff Experimente mit kleinen ...
Blue-Bottle-Experiment Unter dem Blue-Bottle-Experiment versteht man eines der klassischen Show-Experimente in der Chemie. ... Dabei ist darauf zu achten, dass die Konzentration nicht zu hoch ist, da sonst die Reaktion sehr lange zur Regeneration benötigt. Nun gibt man 400 ml dest. Wasser in einen Rundkolben und löst darin 5 g NaOH-Plätzchen ...
HOL DIR JETZT DIE SIMPLECLUB APP FÜR BESSERE NOTEN! 😎⤵️https://simpleclub.com/unlimited-yt?variant=pay92hzc7n3&utm_source=youtube_organic&utm_medium=youtube...
A classic demonstration of a redox reaction. Methylene blue is blue when oxidised but its reduced form is colourless. Glucose, in alkaline conditions, is a reducing agent. A bottle or flask is filled 2/3 or so full of a methylene blue - glucose - sodium hydroxide solution and the top sealed. In a few minutes the solution goes clear.
Zum Versuch. Es handelt sich bei der Blue-Bottle-Reaktion um eine durch Methylenblau katalysierte Oxidation der Glucose. Oxidationsmittel ist der Luftsauerstoff. Methylenblau bildet dabei in reversibler Reaktion eine farblose Leukoform (Leukomethylenblau), in der das vorher vorhandene chinoide, mesomerie-stabilisierte System des Methylenblaus ...
Experiment: Versuch: Blue Bottle-Versuch (Blaues Wunder) Es handelt sich bei der Blue Bottle-Reaktion um eine durch Methylenblau (Mb +) katalysierte Oxidation der Glucose. Oxidationsmittel ist letztlich der Luftsauerstoff. Die Mitwirkung des Methylenblaus erkennt man an seiner Entfärbung. Die farblose Stufe MbH kann als Beispiel für eine ...
The famous blue bottle experiment a visually dramatic way to teach reduction-oxidation (redox) chemistry. Students from grade school to grad school find this reaction memorable and it is considered a classic staple in chemical demonstration shows. A half-full bottle of colorless liquid turns blue when shaken, and when the bottle is allowed to ...
A DFT investigation of the blue bottle experiment: E ∘ half-cell analysis of autoxidation catalysed by redox indicators. Royal Society Open Science 2017 , 4 (11) , 170708.
Das hier ist der Versuch mit dem Namen "Blue Bottle". Er wird im Schulunterricht gerne, als Beispiel für Redox-Reaktionen genommen.This experiment is called ...
My favorite deno feature is coming to node directly. Awesome! Maybe this means I don't always have to install esbuild to strip types - very excited how this will make writing scripts in TypeScript that much easier to use.