First principles
Let’s create a minimal Go kit service.
Your business logic
Your service starts with your business logic. In Go kit, we model a service as an interface.
// StringService provides operations on strings.
type StringService interface {
Uppercase(string) (string, error)
Count(string) int
}
That interface will have an implementation.
type stringService struct{}
func (stringService) Uppercase(s string) (string, error) {
if s == "" {
return "", ErrEmpty
}
return strings.ToUpper(s), nil
}
func (stringService) Count(s string) int {
return len(s)
}
// ErrEmpty is returned when input string is empty
var ErrEmpty = errors.New("Empty string")
Requests and responses
In Go kit, the primary messaging pattern is RPC. So, every method in our interface will be modeled as a remote procedure call. For each method, we define request and response structs, capturing all of the input and output parameters respectively.
type uppercaseRequest struct {
S string `json:"s"`
}
type uppercaseResponse struct {
V string `json:"v"`
Err string `json:"err,omitempty"` // errors don't JSON-marshal, so we use a string
}
type countRequest struct {
S string `json:"s"`
}
type countResponse struct {
V int `json:"v"`
}
Endpoints
Go kit provides much of its functionality through an abstraction called an endpoint.
type Endpoint func(ctx context.Context, request interface{}) (response interface{}, err error)
An endpoint represents a single RPC. That is, a single method in our service interface. We’ll write simple adapters to convert each of our service’s methods into an endpoint. Each adapter takes a StringService, and returns an endpoint that corresponds to one of the methods.
import (
"golang.org/x/net/context"
"github.com/go-kit/kit/endpoint"
)
func makeUppercaseEndpoint(svc StringService) endpoint.Endpoint {
return func(ctx context.Context, request interface{}) (interface{}, error) {
req := request.(uppercaseRequest)
v, err := svc.Uppercase(req.S)
if err != nil {
return uppercaseResponse{v, err.Error()}, nil
}
return uppercaseResponse{v, ""}, nil
}
}
func makeCountEndpoint(svc StringService) endpoint.Endpoint {
return func(ctx context.Context, request interface{}) (interface{}, error) {
req := request.(countRequest)
v := svc.Count(req.S)
return countResponse{v}, nil
}
}
Transports
Now we need to expose your service to the outside world, so it can be called. Your organization probably already has opinions about how services should talk to each other. Maybe you use Thrift, or custom JSON over HTTP. Go kit supports many transports out of the box.
For this minimal example service, let’s use JSON over HTTP. Go kit provides a helper struct, in package transport/http.
import (
"encoding/json"
"log"
"net/http"
"golang.org/x/net/context"
httptransport "github.com/go-kit/kit/transport/http"
)
func main() {
svc := stringService{}
uppercaseHandler := httptransport.NewServer(
makeUppercaseEndpoint(svc),
decodeUppercaseRequest,
encodeResponse,
)
countHandler := httptransport.NewServer(
makeCountEndpoint(svc),
decodeCountRequest,
encodeResponse,
)
http.Handle("/uppercase", uppercaseHandler)
http.Handle("/count", countHandler)
log.Fatal(http.ListenAndServe(":8080", nil))
}
func decodeUppercaseRequest(_ context.Context, r *http.Request) (interface{}, error) {
var request uppercaseRequest
if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
return nil, err
}
return request, nil
}
func decodeCountRequest(_ context.Context, r *http.Request) (interface{}, error) {
var request countRequest
if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
return nil, err
}
return request, nil
}
func encodeResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {
return json.NewEncoder(w).Encode(response)
}
stringsvc1
The complete service so far is stringsvc1.
$ go get github.com/go-kit/kit/examples/stringsvc1
$ stringsvc1
$ curl -XPOST -d'{"s":"hello, world"}' localhost:8080/uppercase
{"v":"HELLO, WORLD","err":null}
$ curl -XPOST -d'{"s":"hello, world"}' localhost:8080/count
{"v":12}
Middlewares
No service can be considered production-ready without thorough logging and instrumentation.
Transport logging
Any component that needs to log should treat the logger like a dependency, same as a database connection.
So, we construct our logger in our func main
, and pass it to components that need it.
We never use a globally-scoped logger.
We could pass a logger directly into our stringService implementation, but there’s a better way. Let’s use a middleware, also known as a decorator. A middleware is a function that takes an endpoint and returns an endpoint.
type Middleware func(Endpoint) Endpoint
In between, it can do anything. Let’s create a basic logging middleware.
func loggingMiddleware(logger log.Logger) Middleware {
return func(next endpoint.Endpoint) endpoint.Endpoint {
return func(ctx context.Context, request interface{}) (interface{}, error) {
logger.Log("msg", "calling endpoint")
defer logger.Log("msg", "called endpoint")
return next(ctx, request)
}
}
}
And wire it into each of our handlers.
logger := log.NewLogfmtLogger(os.Stderr)
svc := stringService{}
var uppercase endpoint.Endpoint
uppercase = makeUppercaseEndpoint(svc)
uppercase = loggingMiddleware(log.NewContext(logger).With("method", "uppercase"))(uppercase)
var count endpoint.Endpoint
count = makeCountEndpoint(svc)
count = loggingMiddleware(log.NewContext(logger).With("method", "count"))(count)
uppercaseHandler := httptransport.Server(
// ...
uppercase,
// ...
)
countHandler := httptransport.Server(
// ...
count,
// ...
)
It turns out that this technique is useful for a lot more than just logging. Many Go kit components are implemented as endpoint middlewares.
Application logging
But what if we want to log in our application domain, like the parameters that are passed in? It turns out that we can define a middleware for our service, and get the same nice and composable effects. Since our StringService is defined as an interface, we just need to make a new type which wraps an existing StringService, and performs the extra logging duties.
type loggingMiddleware struct {
logger log.Logger
next StringService
}
func (mw loggingMiddleware) Uppercase(s string) (output string, err error) {
defer func(begin time.Time) {
mw.logger.Log(
"method", "uppercase",
"input", s,
"output", output,
"err", err,
"took", time.Since(begin),
)
}(time.Now())
output, err = mw.next.Uppercase(s)
return
}
func (mw loggingMiddleware) Count(s string) (n int) {
defer func(begin time.Time) {
mw.logger.Log(
"method", "count",
"input", s,
"n", n,
"took", time.Since(begin),
)
}(time.Now())
n = mw.next.Count(s)
return
}
And wire it in.
import (
"os"
"github.com/go-kit/kit/log"
httptransport "github.com/go-kit/kit/transport/http"
)
func main() {
logger := log.NewLogfmtLogger(os.Stderr)
var svc StringService
svc = stringsvc{}
svc = loggingMiddleware{logger, svc}
// ...
uppercaseHandler := httptransport.NewServer(
// ...
makeUppercaseEndpoint(svc),
// ...
)
countHandler := httptransport.NewServer(
// ...
makeCountEndpoint(svc),
// ...
)
}
Use endpoint middlewares for transport-domain concerns, like circuit breaking and rate limiting. Use service middlewares for business-domain concerns, like logging and instrumentation. Speaking of instrumentation…
Application instrumentation
In Go kit, instrumentation means using package metrics to record statistics about your service’s runtime behavior. Counting the number of jobs processed, recording the duration of requests after they’ve finished, and tracking the number of in-flight operations would all be considered instrumentation.
We can use the same middleware pattern that we used for logging.
type instrumentingMiddleware struct {
requestCount metrics.Counter
requestLatency metrics.TimeHistogram
countResult metrics.Histogram
next StringService
}
func (mw instrumentingMiddleware) Uppercase(s string) (output string, err error) {
defer func(begin time.Time) {
methodField := metrics.Field{Key: "method", Value: "uppercase"}
errorField := metrics.Field{Key: "error", Value: fmt.Sprintf("%v", err)}
mw.requestCount.With(methodField).With(errorField).Add(1)
mw.requestLatency.With(methodField).With(errorField).Observe(time.Since(begin))
}(time.Now())
output, err = mw.next.Uppercase(s)
return
}
func (mw instrumentingMiddleware) Count(s string) (n int) {
defer func(begin time.Time) {
methodField := metrics.Field{Key: "method", Value: "count"}
errorField := metrics.Field{Key: "error", Value: fmt.Sprintf("%v", error(nil))}
mw.requestCount.With(methodField).With(errorField).Add(1)
mw.requestLatency.With(methodField).With(errorField).Observe(time.Since(begin))
mw.countResult.Observe(int64(n))
}(time.Now())
n = mw.next.Count(s)
return
}
And wire it into our service.
import (
stdprometheus "github.com/prometheus/client_golang/prometheus"
kitprometheus "github.com/go-kit/kit/metrics/prometheus"
"github.com/go-kit/kit/metrics"
)
func main() {
logger := log.NewLogfmtLogger(os.Stderr)
fieldKeys := []string{"method", "error"}
requestCount := kitprometheus.NewCounter(stdprometheus.CounterOpts{
// ...
}, fieldKeys)
requestLatency := metrics.NewTimeHistogram(time.Microsecond, kitprometheus.NewSummary(stdprometheus.SummaryOpts{
// ...
}, fieldKeys))
countResult := kitprometheus.NewSummary(stdprometheus.SummaryOpts{
// ...
}, []string{}))
var svc StringService
svc = stringService{}
svc = loggingMiddleware{logger, svc}
svc = instrumentingMiddleware{requestCount, requestLatency, countResult, svc}
// ...
http.Handle("/metrics", stdprometheus.Handler())
}
stringsvc2
The complete service so far is stringsvc2.
$ go get github.com/go-kit/kit/examples/stringsvc2
$ stringsvc2
msg=HTTP addr=:8080
$ curl -XPOST -d'{"s":"hello, world"}' localhost:8080/uppercase
{"v":"HELLO, WORLD","err":null}
$ curl -XPOST -d'{"s":"hello, world"}' localhost:8080/count
{"v":12}
method=uppercase input="hello, world" output="HELLO, WORLD" err=null took=2.455µs
method=count input="hello, world" n=12 took=743ns
Calling other services
It’s rare that a service exists in a vacuum. Often, you need to call other services. This is where Go kit shines. We provide transport middlewares to solve many of the problems that come up.
Let’s say that we want to have our string service call out to a different string service to satisfy the Uppercase method. In effect, proxying the request to another service. Let’s implement the proxying middleware as a ServiceMiddleware, same as a logging or instrumenting middleware.
// proxymw implements StringService, forwarding Uppercase requests to the
// provided endpoint, and serving all other (i.e. Count) requests via the
// next StringService.
type proxymw struct {
ctx context.Context
next StringService // Serve most requests via this service...
uppercase endpoint.Endpoint // ...except Uppercase, which gets served by this endpoint
}
Client-side endpoints
We’ve got exactly the same endpoint we already know about, but we’ll use it to invoke, rather than serve, a request. When used this way, we call it a client endpoint. And to invoke the client endpoint, we just do some simple conversions.
func (mw proxymw) Uppercase(s string) (string, error) {
response, err := mw.uppercase(mw.Context, uppercaseRequest{S: s})
if err != nil {
return "", err
}
resp := response.(uppercaseResponse)
if resp.Err != "" {
return resp.V, errors.New(resp.Err)
}
return resp.V, nil
}
Now, to construct one of these proxying middlewares, we convert a proxy URL string to an endpoint. If we assume JSON over HTTP, we can use a helper in the transport/http package.
import (
httptransport "github.com/go-kit/kit/transport/http"
)
func proxyingMiddleware(proxyURL string, ctx context.Context) ServiceMiddleware {
return func(next StringService) StringService {
return proxymw{ctx, next, makeUppercaseEndpoint(ctx, proxyURL)}
}
}
func makeUppercaseEndpoint(ctx context.Context, proxyURL string) endpoint.Endpoint {
return httptransport.NewClient(
"GET",
mustParseURL(proxyURL),
encodeUppercaseRequest,
decodeUppercaseResponse,
).Endpoint()
}
Service discovery and load balancing
That’s fine if we only have a single remote service. But in reality, we’ll probably have many service instances available to us. We want to discover them through some service discovery mechanism, and spread our load across all of them. And if any of those instances start to behave badly, we want to deal with that, without affecting our own service’s reliability.
Go kit offers adapters to different service discovery systems, to get up-to-date sets of instances, exposed as individual endpoints. Those adapters are called subscribers.
type Subscriber interface {
Endpoints() ([]endpoint.Endpoint, error)
}
Internally, subscribers use a provided factory function to convert each discovered instance string (typically host:port) to a usable endpoint.
type Factory func(instance string) (endpoint.Endpoint, error)
So far, our factory function, makeUppercaseEndpoint, just calls the URL directly. But it’s important to put some safety middleware, like circuit breakers and rate limiters, into your factory, too.
var e endpoint.Endpoint
e = makeUppercaseProxy(ctx, instance)
e = circuitbreaker.Gobreaker(gobreaker.NewCircuitBreaker(gobreaker.Settings{}))(e)
e = kitratelimit.NewTokenBucketLimiter(jujuratelimit.NewBucketWithRate(float64(maxQPS), int64(maxQPS)))(e)
}
Now that we’ve got a set of endpoints, we need to choose one. Load balancers wrap subscribers, and select one endpoint from many. Go kit provides a couple of basic load balancers, and it’s easy to write your own if you want more advanced heuristics.
type Balancer interface {
Endpoint() (endpoint.Endpoint, error)
}
Now we have the ability to choose endpoints according to some heuristic. We can use that to provide a single, logical, robust endpoint to consumers. A retry strategy wraps a load balancer, and returns a usable endpoint. The retry strategy will retry failed requests until either the max attempts or timeout has been reached.
func Retry(max int, timeout time.Duration, lb Balancer) endpoint.Endpoint
Let’s wire up our final proxying middleware. For simplicity, we’ll assume the user will specify multiple comma-separate instance endpoints with a flag.
func proxyingMiddleware(instances string, ctx context.Context, logger log.Logger) ServiceMiddleware {
// If instances is empty, don't proxy.
if instances == "" {
logger.Log("proxy_to", "none")
return func(next StringService) StringService { return next }
}
// Set some parameters for our client.
var (
qps = 100 // beyond which we will return an error
maxAttempts = 3 // per request, before giving up
maxTime = 250 * time.Millisecond // wallclock time, before giving up
)
// Otherwise, construct an endpoint for each instance in the list, and add
// it to a fixed set of endpoints. In a real service, rather than doing this
// by hand, you'd probably use package sd's support for your service
// discovery system.
var (
instanceList = split(instances)
subscriber sd.FixedSubscriber
)
logger.Log("proxy_to", fmt.Sprint(instanceList))
for _, instance := range instanceList {
var e endpoint.Endpoint
e = makeUppercaseProxy(ctx, instance)
e = circuitbreaker.Gobreaker(gobreaker.NewCircuitBreaker(gobreaker.Settings{}))(e)
e = kitratelimit.NewTokenBucketLimiter(jujuratelimit.NewBucketWithRate(float64(qps), int64(qps)))(e)
subscriber = append(subscriber, e)
}
// Now, build a single, retrying, load-balancing endpoint out of all of
// those individual endpoints.
balancer := lb.NewRoundRobin(subscriber)
retry := lb.Retry(maxAttempts, maxTime, balancer)
// And finally, return the ServiceMiddleware, implemented by proxymw.
return func(next StringService) StringService {
return proxymw{ctx, next, retry}
}
}
stringsvc3
The complete service so far is stringsvc3.
$ go get github.com/go-kit/kit/examples/stringsvc3
$ stringsvc3 -listen=:8001 &
listen=:8001 caller=proxying.go:25 proxy_to=none
listen=:8001 caller=main.go:72 msg=HTTP addr=:8001
$ stringsvc3 -listen=:8002 &
listen=:8002 caller=proxying.go:25 proxy_to=none
listen=:8002 caller=main.go:72 msg=HTTP addr=:8002
$ stringsvc3 -listen=:8003 &
listen=:8003 caller=proxying.go:25 proxy_to=none
listen=:8003 caller=main.go:72 msg=HTTP addr=:8003
$ stringsvc3 -listen=:8080 -proxy=localhost:8001,localhost:8002,localhost:8003
listen=:8080 caller=proxying.go:29 proxy_to="[localhost:8001 localhost:8002 localhost:8003]"
listen=:8080 caller=main.go:72 msg=HTTP addr=:8080
$ for s in foo bar baz ; do curl -d"{\"s\":\"$s\"}" localhost:8080/uppercase ; done
{"v":"FOO","err":null}
{"v":"BAR","err":null}
{"v":"BAZ","err":null}
listen=:8001 caller=logging.go:28 method=uppercase input=foo output=FOO err=null took=5.168µs
listen=:8080 caller=logging.go:28 method=uppercase input=foo output=FOO err=null took=4.39012ms
listen=:8002 caller=logging.go:28 method=uppercase input=bar output=BAR err=null took=5.445µs
listen=:8080 caller=logging.go:28 method=uppercase input=bar output=BAR err=null took=2.04831ms
listen=:8003 caller=logging.go:28 method=uppercase input=baz output=BAZ err=null took=3.285µs
listen=:8080 caller=logging.go:28 method=uppercase input=baz output=BAZ err=null took=1.388155ms
Advanced topics
Threading a context
The context object is used to carry information across conceptual boundaries in the scope of a single request. In our example, we haven’t yet threaded the context through our business logic. But that’s almost always a good idea. It allows you to pass request-scoped information between business logic and middlewares, and is necessary for more sophisticated tasks like granular distributed tracing annotations.
Concretely, this means your business logic interfaces will look like
type MyService interface {
Foo(context.Context, string, int) (string, error)
Bar(context.Context, string) error
Baz(context.Context) (int, error)
}
Distributed tracing
Once your infrastructure grows beyond a certain size, it becomes important to trace requests through multiple services, so you can identify and troubleshoot hotspots. See package tracing for more information.
Creating a client package
It’s possible to use Go kit to create a client package to your service, to make consuming your service easier from other Go programs. Effectively, your client package will provide an implementation of your service interface, which invokes a remote service instance using a specific transport. See package addsvc/client or package profilesvc/client for examples.


{$title}
分类列表
{foreach $pCategoryList as $pcate}
{$pcate.name}
{/foreach}
{include file="common/header" /} {include file="common/menu" /}


Web apps need to communicate with the server in real-time
...sort of
Full credit for the following diagrams goes to Tieme from his post on StackOverflow
Client sends AJAX request to server, server responds
Client sends AJAX request to server, server keeps request open until response available
Client immediately sends another long-poll request after receiving response
(also see Comet)
Client opens connection with server
Server sends data to client as it becomes available
Client opens connection with server
Client and server send data to each other as data becomes available on either side
GET /mychat HTTP/1.1
Host: server.example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==
Sec-WebSocket-Protocol: chat
Sec-WebSocket-Version: 13
Origin: http://example.com
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: HSmrc0sMlYUkAGmm5OPpG2HaGWk=
Sec-WebSocket-Protocol: chat
*WebSocket protocol handshake via Wikipedia.
Allows bi-directional communication over standard HTTP ports
(great for existing servers, proxies, and firewalls, which open 80 & 443)
Defines new protocols, ws://
and wss://
for standard and secure WebSocket connections
Rest of WebSockets URI follows standard URI scheme
var connection = new WebSocket('ws://subdomain.examnple.com/some-endpoint')
connection.onopen = function(e) {
console.log("Connected");
};
connection.onmessage = function(e) {
console.log( "Received: " + e.data);
};
connection.onclose = function(e) {
console.log("Connection closed");
};
WebSockets is cross-domain by default
Up to you to optionally restrict domain access on server via Origin
header
GET ws://echo.websocket.org/?encoding=text HTTP/1.1
Origin: http://websocket.org
Cookie: __utma=99as
Connection: Upgrade
Host: echo.websocket.org
Sec-WebSocket-Key: uRovscZjNol/umbTt5uKmw==
Upgrade: websocket
Sec-WebSocket-Version: 13
HTTP/1.1 101 WebSocket Protocol Handshake
Date: Fri, 10 Feb 2012 17:38:18 GMT
Connection: Upgrade
Server: Kaazing Gateway
Upgrade: WebSocket
Access-Control-Allow-Origin: http://websocket.org
Access-Control-Allow-Credentials: true
Sec-WebSocket-Accept: rLHCkw/SKsO9GAH/ZSFhBATDKrU=
Access-Control-Allow-Headers: content-type
*WebSocket protocol handshake via websocket.org.
Built-in method for defining WebSocket extensions via RFC
Current extensions include perframe-deflate and multiplexing
var connection = new WebSocket('ws://html5rocks.websocket.org/echo', ['soap', 'xmpp']);
(See currently defined subprotocols)
Original WebSocket spec allowed for strings
Now also allows buffered arrays and blobs
connection.send('your message');
var img = canvas_context.getImageData(0, 0, 400, 320);
var binary = new Uint8Array(img.data.length);
for (var i = 0; i < img.data.length; i++) {
binary[i] = img.data[i];
}
connection.send(binary.buffer);
var file = document.querySelector('input[type="file"]').files[0];
connection.send(file);
(brain-dump)
Doesn't support sending/receiving JSON (yet)
Can be accomplished by serializing/deserializing
var WebSocketServer = require('ws').Server,
wss = new WebSocketServer({port: 8080});
wss.on('connection', function(ws) {
ws.send(JSON.stringify({
attribute: 'connected'
}));
});
connection.onmessage = function (e) {
var response = JSON.parse(e.data);
};
Not really meant for server-to-server communication; better off using UDP or some other low-overhead transfer protocol if you control both servers
Not meant for browser-to-browser communication; that's what WebRTC is for
Using ws
in production can cause WebSockets communication to fail due to invisible proxies that can't do WebSockets
Using wss
forces browser to issue HTTP_CONNECT
statement to proxy server, which sets up tunnel
So use wss
in production
Initial HTTP handshake to server requests WebSocket upgrade
Server upgrades connection if it knows how
Support can be added to most servers (modules exist for Nginx, Apache, etc.)
Server can be built in any language, which supports event loop
Libraries exist for many languages, including Node, Ruby, Python, PHP, etc. (see list of libraries via Wikipedia)
All modern browsers (including IE10 support WebSockets)
Except Android Browser (but supported in Mobile Chrome, avail on Android >= 4.0, default on Android >= 4.2)
Server and client-side implementation (for Node on server side)
Abstracts WebSocket communications to automatically fall back to flash streaming or long-polling when necessary (on either server or client)
Adds features like heartbeats, timeouts, and disconnection support not provided in WebSocket API


Portfolio of Dylan Sanders
Home
About me
GitHub
facebook
twitter
Filter by ...a
Filter by ...b
Welcome to my fake Portfolio
My experience
Coding projects
Total projects:
Total words:
TAPP (Total Awesomeness Per Project):


Welcome to Town of Oz
Select
Home
Events
Directions
Weather
Wizards
Welcome to Oz!
Information Panel
[EMAIL]
[ABOUT]


Download Failed
Error in red field
Before using the Encrypt/Decrypt features, please acquire the KGS's public and your personal Keys (see Generate Keys Tab)
File Selected


R.I.O.T. THE MOVIE A film review by Andrew Hicks Copyright 1996 Andrew Hicks / Fatboy Productions
*
Outside the Christian community, people will just look back at you blankly when you ask if they've heard of Carman. Then, when you try to explain the man's succees in the contemporary Christian music industry, they find it even more unbelievable. Believe me, even those of us who have been buying his CD's since the mid-80's can't defend the man because, since about 1989, he's tried to bend over backwards to gain acceptance in youth circles despite being well over forty and catching onto every musical trend several years late.
In 1989 he did a little ditty called "The Resurrection Rap" that sounded like the worst early 80's pop rap and had lyrics like "I got the deffest, freshest tale to tell / About how Christ saved my soul from hell" and "When Christ talks, you best be chill / He made the wind and the waves stand still." In 1993 he jumped on the Vanilla Ice / M.C. Hammer hip-hop bandwagon with a song called "Who's in the House?" ("JC!") And on the new R.I.O.T. album, the companion piece to this movie, he's adopting an early 90's Technotronic / 2 Unlimited / "Rhythm is a Dancer" sound.
That's just one reason none of us who were raised on Carman can think the man has any degree of coolness, but he's also a beefy Italian who talks like Stallone and tries to be the Renaissance Man of Christian music. Besides the albums, there are books, music videos, even a video talk show that Carman does once a month called "Time 2."
The R.I.O.T. movie starts out with a preview for the "Time 2" video series. At the end, Carman comes on and says to the camera, "Become a 'Time 2' Video Club member and we'll have a pretty good time together..." then he goes into an expression of deep, contemplative thought and shakes his head, amending his statement. "Aw, who am I kidding? We'll have a straight-up blast!"  I was waiting for him to add, after the "straight-up blast" line, "You'll laugh so hard you'll soil the couch!  Your death certificate will read 'Overdose of Laughter'!"
Then comes the R.I.O.T. movie itself, which you can find for rent at any fine Christian bookstore. Carman plays tough- as-nails cop Vic Rizzo (no, seriously), who decides to move from Chicago to Broken Arrow, Oklahoma after his kid, Little Vic (no, seriously), goes into the school bathroom and has a run-in with some gang members. Luckily, his beautiful teacher comes to the rescue just in time ("Gee, he's been in the bathroom for fifteen seconds already -- something must be wrong!") and the gang members split.
Cut to the next scene, where Carman gives his son and the teacher a lecture about how some kids aren't actually in gangs but dress to emulate gang members. "We call them 'bustas' or 'wannabes'," Carman says with a straight face, little realizing he, as an old man futilely trying to keep up with youth culture, is the biggest wannabe of them all.
The head gang member is played by Christian rapper T-Bone (the name "Ribeye" was taken), whose only hit song so far features the lyrics, "I'm the lyrical assassin / My lyrics go bup- bup-bup / And all the demons get struck." There's a scene toward the beginning where T-Bone is running from Carman Rizzo and he reaches a locked door and begins banging on it. If the screen writer had only thought to have T-Bone yell out, "Bup-bup-open up!" the movie as a whole would have been worth watching.
But the attempts at humor aren't quite on the "bup- bup-open-up" level.  He says, "Get your feet off the counter!" and breaks the guy's balance with his nightstick.
As far as the plot goes, Carman soon finds that there are even gang problems in Broken Arrow and has to face down his own fears while inevitably romancing the beautiful elementary school teacher. Twice his children are unbelievably placed in jeopardy, once when Little Vic is inexplicably at school in the middle of the night and another where his prepubescent daughter is assaulted while working at the diner. The girl can't be more than eleven years old and we know child labor laws don't allow that kind of work, but her presence there is never explained, unless it's she's working in the Kathie Lee Sweatstaraunt.
And every ten minutes or so, completely unrelated to the plot, a music video from the R.I.O.T. album pops up. The videos are on an equally pathetic level with the movie itself, ranging from the Janet Jackson / Paula Abdul ripoff title track ("We are a part of the Jesus nation") to the Billy Ray Carman line-dance song "Step of Faith" and THRILLER ripoff "No Monsters." There's even a nine- minute epic called "There is a God," where Carman points out all the intricacies of the earth and universe in a song that steals the chords from "We Are the World." Interesting how God could create the world in seven days but Carman couldn't create a new chord progression.
As a whole, R.I.O.T. The Movie is nothing you should hunt down unless you're already familiar with the man (the CARman, that is). And if you like movies that are bad enough to laugh at, this one defies all belief. It makes it all the more masochistically enjoyable knowing that Carman really thought he was making a good movie with entertaining doses of comedy, drama and action. But believe me, and believe I'm riot, this movie is none of the above. If there was a "Jesus Christ Theater 3000" showcase for bad Christian movies, R.I.O.T. would be the main attraction.
--
Visit the Movie Critic at LARGE homepage at http://www.missouri.edu/~c667778/movies.html Serving America For Over 1/50th of a Century!
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


The term "iOS" was originally know as "iPhone OS" and was introduced in 2007 along with the first iPhone hardware device Apple released. It was the term used to describe the software that would operate the iPhone and is derived from the term "OS X", which is how Apple describes its "operating system" for its Macintosh computers. The "X" stands for 10 which is the newest version of the computer software Apple created to operate the desktop and laptop computers they design. The "iOS" platform is a mobile-device-based software system that works like a computer system, but on mobile devices like portable phones. It is designed to be smaller, faster and use less power. It also has a "touch" friendly user interface so it works better when a finger is used to interface with the system instead of a mouse or stylus that has been used in the past to interact with operating systems. The iPhone has run on iOS since its release in 2007.


|
Team 302 Robot
|
#include <pugixml.hpp>
Public Member Functions | |
| const char_t * | name () const |
| xpath_value_type | type () const |
| bool | get_boolean () const |
| double | get_number () const |
| const char_t * | get_string () const |
| const xpath_node_set & | get_node_set () const |
| bool | set (bool value) |
| bool | set (double value) |
| bool | set (const char_t *value) |
| bool | set (const xpath_node_set &value) |
Protected Member Functions | |
| xpath_variable (xpath_value_type type) | |
| xpath_variable (const xpath_variable &) | |
| xpath_variable & | operator= (const xpath_variable &) |
Protected Attributes | |
| xpath_value_type | _type |
| xpath_variable * | _next |
Friends | |
| class | xpath_variable_set |
Definition at line 1075 of file pugixml.hpp.
|
protected |
Definition at line 12058 of file pugixml.cpp.
|
protected |
| PUGI__FN bool xpath_variable::get_boolean | ( | ) | const |
Definition at line 12089 of file pugixml.cpp.
| const PUGI__FN xpath_node_set & xpath_variable::get_node_set | ( | ) | const |
Definition at line 12105 of file pugixml.cpp.
| PUGI__FN double xpath_variable::get_number | ( | ) | const |
Definition at line 12094 of file pugixml.cpp.
Definition at line 12099 of file pugixml.cpp.
Definition at line 12062 of file pugixml.cpp.
|
protected |
| PUGI__FN bool xpath_variable::set | ( | bool | value | ) |
Definition at line 12110 of file pugixml.cpp.
Definition at line 12126 of file pugixml.cpp.
| PUGI__FN bool xpath_variable::set | ( | const xpath_node_set & | value | ) |
Definition at line 12147 of file pugixml.cpp.
| PUGI__FN bool xpath_variable::set | ( | double | value | ) |
Definition at line 12118 of file pugixml.cpp.
| PUGI__FN xpath_value_type xpath_variable::type | ( | ) | const |
Definition at line 12084 of file pugixml.cpp.
|
friend |
Definition at line 1077 of file pugixml.hpp.
|
protected |
Definition at line 1081 of file pugixml.hpp.
|
protected |
Definition at line 1080 of file pugixml.hpp.


A JavaScript function is executed when "something" invokes it (calls it).
JavaScript Function Syntax
- A JavaScript function is defined with the function keyword, followed by a name, followed by parentheses ().
- Function names can contain letters, digits, underscores, and dollar signs (same rules as variables).
- The parentheses may include parameter names separated by commas:
(parameter1, parameter2, ...)
- The code to be executed, by the function, is placed inside curly brackets: {}
Function parameters are listed inside the parentheses () in the function definition.
Function arguments are the values received by the function when it is invoked.
Inside the function, the arguments (the parameters) behave as local variables.
A Function is much the same as a Procedure or a Subroutine, in other programming languages.
Function Invocation
The code inside the function will execute when "something" invokes (calls) the function:
- When an event occurs (when a user clicks a button)
When it is invoked (called) from JavaScript code
utomatically (self invoked)


libARUpdater Uploader header file.
More...
#include <libARUpdater/ARUPDATER_Manager.h>
#include <libARDiscovery/ARDISCOVERY_Discovery.h>
#include <libARSAL/ARSAL_MD5_Manager.h>
Go to the source code of this file.
| typedef void(* ARUPDATER_Uploader_PlfUploadCompletionCallback_t)(void *arg, eARUPDATER_ERROR error) |
Completion callback of the Plf upload.
- Parameters
-
| arg | The pointer of the user custom argument |
| error | The error status to indicate the plf upload status |
- See Also
- ARUPDATER_Manager_CheckLocaleVersionThreadRun ()
| typedef void(* ARUPDATER_Uploader_PlfUploadProgressCallback_t)(void *arg, float percent) |
Progress callback of the upload.
- Parameters
-
| arg | The pointer of the user custom argument |
| percent | The percent size of the plf file already uploaded |
- See Also
- ARUPDATER_Manager_CheckLocaleVersionThreadRun ()
Delete the Uploader of the Manager.
- Warning
- This function frees memory
- Parameters
-
| manager | a pointer on the ARUpdater Manager |
- See Also
- ARUPDATER_Uploader_New ()
Create an object to upload a plf file.
- Warning
- this function allocates memory
- Postcondition
- ARUPDATER_Uploader_Delete should be called
- Parameters
-
| manager | : pointer on the manager |
| [in] | rootFolder | : root folder |
| [in] | ftpManager | : ftp manager initialized with the correct network (wifi or ble) |
| [in] | md5Manager | : md5 manager |
| [in] | product | : enumerator on the enum |
| [in] | progressCallback | : callback which tells the progress of the download |
| in|out] | progressArg : arg given to the progressCallback |
| [in] | completionCallback | : callback which tells when the download is completed |
| in|out] | completionArg : arg given to the completionCallback |
- Returns
- ARUPDATER_OK if operation went well, a description of the error otherwise
- See Also
- ARUPDATER_Uploader_Delete()
Get if the thread is still running.
- Parameters
-
| manager | : pointer on the manager |
| [out] | error | : pointer on an error. This can be null |
- Returns
- 1 if the upload thread is running, 0 otherwise
| void* ARUPDATER_Uploader_ThreadRun |
( |
void * |
managerArg | ) |
|


Ahoj Aničko, toto je tvůj první blog post.
To add new posts, simply add a file in the _posts
directory that follows the convention YYYY-MM-DD-name-of-post.ext
and includes the necessary front matter. Take a look at the source for this post to get an idea about how it works.
If you list one or more categories or tags in the front matter of your post, they will be included with the post on the page as links. Clicking the link will bring you to an auto-generated archive page for the category or tag, created using the jekyll-archive gem.
To add a cover image to your post, set the “cover” property in the front matter with the relative URL of the image (i.e. cover: "/assets/cover_image.jpg"
).
You can use highlight.js to add syntax highlig code snippets:
function demo(string, times) {
for (var i = 0; i < times; i++) {
console.log(string);
}
}
demo("hello, world!", 10);
Lightbox has been enabled for images. To create the link that’ll launch the lightbox, add data-lightbox
and data-title
attributes to an
tag around your
tag. The result is:
For more information, check out the Lightbox website.
Check out the Jekyll docs for more info on how to get the most out of Jekyll. File all bugs/feature requests at Jekyll’s GitHub repo. If you have questions, you can ask them on Jekyll’s dedicated Help repository.


@main("Dashboard", true) {
Practice coding, logically
Coding Boot Camp is an educational tool for new programming students.


UK Labour Party Has Reportedly Experienced 'Sophisticated and Large Scale Cyber Attack'
The UK Labour party said that it has experienced a “sophisticated and large scale cyber attack” on its digital platforms, according to the Evening Standard.
According to the Labour party the attacks on its platforms failed due to "robust security systems."
"We have experienced a sophisticated and large scale cyber attack on Labour digital platforms. We took swift action and these attempts failed due to our robust security systems. The integrity of all our platforms was maintained and we are confident that no data breach occurred," Labour spokeswoman said.
As a result, the party's campaign activities ahead of the general election were initially "slowed down" but then returned "to full speed," the broadcaster reported, spokeswoman said.
"We have reported the matter to the National Cyber Security Centre," the spokeswoman was quoted as saying.
On 17 October, London and Brussels finally reached a new Brexit deal after protracted negotiations. The new Brexit draft has dropped the controversial Irish backstop that was the main source of concern for opponents of the previous divorce agreement.
The deal, however, was met with strong resistance in the UK parliament, prompting a decision to hold a snap general election on 12 December.
The UK exit from the bloc is currently scheduled for 31 January.


This tests for a bug in InsertLineBreakCommand. Only one line break should be inserted and the caret should end up at the end of the bordered div below.


The GRIB product is broken down into several subsections:
Tables:
Each section is described below.
The values saved in a GRIB file are packed. The actual data value is derived from the following parameters:
Each gridpoint value (Y) is determined from the following formula:
Y * 10D = R + (X * 2E)
The reference value (R) uses IBM single precision floating point format.
sAAAAAAA BBBBBBBB BBBBBBBB BBBBBBBB
The appropriate formula to recover the value of R is:
R = (-1)s * 2(-24) * B * 16(A-64)
| Byte/Octet | Description |
| 01-04 | "GRIB" - ASCII characters to flag data as GRIB data |
| 05-07 | Total number of bytes for all data |
| 08 | GRIB edition - currently 1 |
Octet/Byte |
Description |
01-03 |
Length in bytes of PDS |
04 |
Parameter table version number - currently 2 for international exchange |
05 |
|
06 |
Generating process or model ID (center dependent) |
07 |
Grid identification - used for fixed grid types, GDS is used for specific grid definition |
08 |
|
09 |
|
10 |
|
11-12 |
|
| 13 | Reference Time - Year of century |
| 14 | Month of year |
| 15 | Day of month |
| 16 | Hour of day |
| 17 | Minute of hour |
18 |
|
19 |
P1 - Period of time (Number of time units). 0 for analysis or initialized analysis. |
20 |
P2 - Period of time (Number of time units) or time interval between successive analyses, successive initialized analyses, or forecasts, undergoing averaging or accumulation. |
21 |
|
22-23 |
Number included in average, when octet 21 (Table 5) indicates an average or accumulation; otherwise set to zero. |
24 |
Number Missing from averages or accumulations. |
25 |
Century of Initial (Reference) time (=20 until Jan. 1, 2001, 21 afterwards) |
26 |
Identification of sub-center |
27-28 |
The decimal scale factor D. A negative value is indicated by setting the high order bit (bit No. 1) in octet 27 to 1 (on). |
29-40 |
Reserved (need not be present) |
41-nnn |
Reserved for originating center use. |
Byte/Octet |
Description |
01-03 |
Length in bytes of the GDS |
04 |
NV, the number of vertical coordinate parameters |
05 |
PV, the location (octet number) of the list of vertical coordinate parameters, if present or PL, the location (octet number) of the list of numbers of points in each row (when no vertical parameters are present), if present or (all bits set to 1) if neither are present |
06 |
|
07-32 |
Grid description, according to data representation type, except Lambert, Mercator or Space View. |
07-42 |
Grid description for Lambert or Mercator grid |
07-44 |
Grid description for Space View perspective grid |
PV |
List of vertical coordinate parameters. length = NV x 4 octets; if present, then PL = 4 x NV + PV |
PL |
List of numbers of points in each row, used for quasi-regular grids. length = NROWS x 2 octets, where NROWS is the total number of rows defined within the grid description |
Note: NV and PV relate to features of GRIB not, at present, in use in international exchange. See the WMO Manual on Codes for the descriptions of those features.
PL is used for "quasi-regular" or "thinned" grids; e.g., a lat/lon grid where the number of points in each row is reduced as one moves poleward from the equator. The reduction usually follows some mathematical formula involving the cosine of the latitude, to generate an (approximately) equally spaced grid array. The association of the numbers in octet PL (and following) with the particular row follows the scanning mode specification in Table 8.
| Octet/Byte | Description |
| 07-08 | Ni - No. of points along a latitude circle |
| 09-10 | Nj - No. of points along a longitude meridian |
| 11-13 | La1 - latitude of first grid point
units: millidegrees (degrees x 1000) values limited to range 0 - 90,000 bit 1 (leftmost) set to 1 for south latitude |
| 14-16 | Lo1 - longitude of first grid point
units: millidegrees (degrees x 1000) values limited to range 0 - 360,000 bit 1 (leftmost) set to 1 for west longitude |
| 17 | Resolution and component flags |
| 18-20 | La2 - Latitude of last grid point (same units, value range, and bit 1 as La1) |
| 21-23 | Lo2 - Longitude of last grid point (same units, value range, and bit 1 as Lo1) |
| 24-25 | Di - Longitudinal Direction Increment (same units as Lo1) (if not given, all bits set = 1) |
| 26 - 27 | Regular Lat/Lon Grid: Dj - Latitudinal Direction Increment (same units as La1) (if not given, all bits set = 1) Gaussian Grid: N - number of latitude circles between a pole and the equator. Mandatory if Gaussian Grid specified |
| 28 | Scanning mode flags |
| 29 - 32 | Reserved (set to zero) |
Notes:
Octet |
CONTENT & MEANING |
07-08 |
Nx - Number of points along x-axis |
09-10 |
Ny - Number of points along y-axis |
11-13 |
La1 - Latitude of first grid point |
14-16 |
Lo1 - Longitude of first grid point |
17 |
|
18-20 |
Lov - The orientation of the grid; i.e., the east longitude value of the meridian which is parallel to the y-axis (or columns of the grid) along which latitude increases as the y-coordinate increases. (Note: The orientation longitude may, or may not, appear within a particular grid.) |
21-23 |
Dx - the X-direction grid length (see note 2) |
24-26 |
Dy - the Y-direction grid length (see note 2) |
27 |
Projection center flag (see note 5) |
28 |
|
29 - 32 |
Set to 0 (reserved) |
Notes:
Octet |
CONTENT & MEANING |
07-08 |
Nx - Number of points along x-axis |
09-10 |
Ny - Number of points along y-axis |
11-13 |
La1 - Latitude of first grid point |
14-16 |
Lo1 - Longitude of first grid point |
17 |
|
18-20 |
Lov - The orientation of the grid; i.e., the east longitude value of the meridian which is parallel to the y-axis (or columns of the grid) along which latitude increases as the y-coordinate increases. (Note: The orientation longitude may, or may not, appear within a particular grid.) |
21-23 |
Dx - the X-direction grid length (see note 2) |
24-26 |
Dy - the Y-direction grid length (see note 2) |
27 |
Projection center flag (see note 5) |
28 |
|
29-31 |
Latin 1 - The first latitude from the pole at which the secant cone cuts the spherical earth. (See Note 8) |
32-34 |
Latin 2 - The second latitude from the pole at which the secant cone cuts the spherical earth. (See Note 8) |
35-37 |
Latitude of southern pole (millidegrees) |
38-40 |
Longitude of southern pole (millidegrees) |
41-42 |
Reserved (set to 0) |
Notes:
| Octet | CONTENT & MEANING |
| 07-08 | Ni - Number of points along a latitude circle |
| 09-10 | Nj - Number of points along a longitude meridian |
| 11-13 | La1 - Latitude of first grid point |
| 14-16 | Lo1 - Longitude of first grid point |
| 17 | Resolution and component flags |
| 18-20 | La2 - latitude of last grid point |
| 21-23 | Lo2 - longitude of last grid point |
| 24-26 | Latin - The latitude(s) at which the Mercator projection cylinder intersects the earth. |
| 27 | Reserved (set to 0) |
| 28 | Scanning mode |
| 29-31 | Di - the longitudinal direction increment (see Note 2) |
| 32-34 | Dj - the latitudinal direction increment (see note 2) |
| 35-42 | Reserved (set to 0) |
Notes:
Octet |
CONTENTS |
07-08 |
Nx - number of points along x axis (columns) |
09-10 |
Ny - number of points along y axis (rows or lines) |
11-13 |
Lap - latitude of sub-satellite point |
14-16 |
Lop - longitude of sub-satellite point |
17 |
Resolution and component flags (Table 7) |
18-20 |
dx - apparent diameter of earth in grid lengths, in x direction |
21-23 |
dy - apparent diameter of earth in grid lengths, in y direction |
24-25 |
Xp - X-coordinate of sub satellite point |
26-27 |
Yp - Y-coordinate of sub-satellite point |
28 |
Scanning Mode (Table 8) |
29-31 |
the orientation of the grid; i.e., the angle in millidegrees between the increasing y axis and the meridian of the sub-satellite point in the direction of increasing latitude (see Note 3). |
32-34 |
Nr - the altitude of the camera from the earth's center, measured in units of the earth's (equatorial) radius (See Note 4). |
35-44 |
reserved |
Notes:
Rx = 2 x asin(1/Nr) / dx
Ry = 2 x asin(1/Nr) / dy
This section defines which grid points will be presented in the Binary Data Section. A 1 value indicates a value will appear. A 0 value means it will be absent.
Octet |
|
01-03 |
Length in bytes of BMS |
04 |
Number of unused bits at end of Section 3. |
05-06 |
Numeric: if 0: a bit map follows; |
07-nnn |
Bit map, zero filled to an even number of octets |
This section contains the packed binary data.
Octet |
|
01-03 |
Length in octets of binary data section |
04 |
Bits 1 through 4: Flag |
05-06 |
The binary scale factor (E). A negative value is indicated by setting the high order bit (bit No. 1) in octet 5 to 1 (on). |
07-10 |
Reference value (minimum value); floating point representation of the number. |
11 |
Number of bits into which a datum point is packed |
12-nnn |
Variable, depending on octet 4; zero filled to an even number of octets. |
14 |
Optionally, may contain an extension of the flags in octet 4. |
This is a key sequence used to denote the end of a GRIB product.
| Octet | |
| 1-4 | "7777" |
| Value | Contents |
| 07 | US Weather Service - National Met. Center |
| 08 | US Weather Service - NWS Telecomms Gateway |
| 09 | US Weather Service - Field Stations |
| 34 | Japanese Meteorological Agency - Tokyo |
| 52 | National Hurricane Center, Miami |
| 54 | Canadian Meteorological Service - Montreal |
| 57 | U.S. Air Force - Global Weather Center |
| 58 | US Navy - Fleet Numerical Oceanography Center |
| 59 | NOAA Forecast Systems Lab, Boulder CO |
| 74 | U.K. Met Office - Bracknell |
| 85 | French Weather Service - Toulouse |
| 97 | European Space Agency (ESA) |
| 98 | European Center for Medium-Range Weather Forecasts - Reading |
| 99 | DeBilt, Netherlands |
NCEP values:
| Value | Contents |
| 10 | Significant Wind Wave model |
| 19 | LFM model |
| 25 | Snow Cover analysis |
| 39 | NGM model |
| 43 | Global Optimal Interpolation analysis |
| 44 | Sea Surface Temperature analysis |
| 46 | Spectral model - 30 wave |
| 53 | LFM analysis |
| 64 | Regional Optimal Interpolation analysis |
| 69, 77, 81, 96 | Aviation (AVN) model |
| 78, 80, 82, 94 | Medium Range Forecast (MRF) model |
| 83, 84, 85, 89 | Eta model |
| 86 | RUC model |
International Exchange Grids
Value |
Resolution |
Area |
Grid Shape |
Gridpoints |
|
21 |
5.0 x 2.5 |
0-180E, 0-90N |
37 |
36 + pole |
1333 |
22 |
5.0 x 2.5 |
180W-0, 0-90N |
37 |
36 + pole |
1333 |
23 |
5.0 x 2.5 |
0-180E, 90S-0 |
pole + 37 |
36 |
1333 |
24 |
5.0 x 2.5 |
180W-0, 90S-0 |
pole + 37 |
36 |
1333 |
25 |
5.0 x 5.0 |
0-355E, 0-90N |
72 |
18 + pole |
1297 |
26 |
5.0 x 5.0 |
0-355E, 90S-0 |
pole + 72 |
18 |
1297 |
61 |
2.0 x 2.0 |
0-180E, 0-90N |
91 |
45 + pole |
4096 |
62 |
2.0 x 2.0 |
180W-0, 0-90N |
91 |
45 + pole |
4096 |
63 |
2.0 x 2.0 |
0-180E, 90S-0 |
pole + 91 |
45 |
4096 |
64 |
2.0 x 2.0 |
180W-0, 90S-0 |
pole + 91 |
45 |
4096 |
255 |
(non-standard grid - defined in the GDS) |
| BIT | VALUE | MEANING |
| 1 | 0 | GDS Omitted |
| 1 | GDS Included | |
| 2 | 0 | BMS Omitted |
| 1 | BMS Included | |
| 3-8 | 0 | reserved |
| VALUE | PARAMETER | UNITS |
| 000 | Reserved | |
| 001 | Pressure | Pa |
| 002 | Pressure reduced to MSL | Pa |
| 003 | Pressure tendency | Pa/s |
| 004 | ||
| 005 | ||
| 006 | Geopotential | m2/s2 |
| 007 | Geopotential height | Gpm |
| 008 | Geometric height | M |
| 009 | Standard deviation of height | M |
| 010 | ||
| 011 | Temperature | K |
| 012 | Virtual temperature | K |
| 013 | Potential temperature | K |
| 014 | Pseudo-adiabatic potential temperature | K |
| 015 | Maximum temperature | K |
| 016 | Minimum temperature | K |
| 017 | Dew point temperature | K |
| 018 | Dew point depression (or deficit) | K |
| 019 | Lapse rate | K/m |
| 020 | Visibility | M |
| 021 | Radar Spectra (1) | - |
| 022 | Radar Spectra (2) | - |
| 023 | Radar Spectra (3) | - |
| 024 | ||
| 025 | Temperature anomaly | K |
| 026 | Pressure anomaly | Pa |
| 027 | Geopotential height anomaly | Gpm |
| 028 | Wave Spectra (1) | - |
| 029 | Wave Spectra (2) | - |
| 030 | Wave Spectra (3) | - |
| 031 | Wind direction | Deg. true |
| 032 | Wind speed | m/s |
| 033 | u-component of wind | m/s |
| 034 | v-component of wind | m/s |
| 035 | Stream function | m2/s |
| 036 | Velocity potential | m2/s |
| 037 | Montgomery stream function | m2/s2 |
| 038 | Sigma coord. vertical velocity | s /s |
| 039 | Pressure Vertical velocity | Pa/s |
| 040 | Geometric Vertical velocity | m/s |
| 041 | Absolute vorticity | /s |
| 042 | Absolute divergence | /s |
| 043 | Relative vorticity | /s |
| 044 | Relative divergence | /s |
| 045 | Vertical u-component shear | /s |
| 046 | Vertical v-component shear | /s |
| 047 | Direction of current | Deg. true |
| 048 | Speed of current | m/s |
| 049 | u-component of current | m/s |
| 050 | v-component of current | m/s |
| 051 | Specific humidity | kg/kg |
| 052 | Relative humidity | % |
| 053 | Humidity mixing ratio | kg/kg |
| 054 | Precipitable water | kg/m2 |
| 055 | Vapor pressure | Pa |
| 056 | Saturation deficit | Pa |
| 057 | Evaporation | kg/m2 |
| 058 | Cloud Ice | kg/m2 |
| 059 | Precipitation rate | kg/m2/s |
| 060 | Thunderstorm probability | % |
| 061 | Total precipitation | kg/m2 |
| 062 | Large scale precipitation | kg/m2 |
| 063 | Convective precipitation | kg/m2 |
| 064 | Snowfall rate water equivalent | kg/m2s |
| 065 | Water equiv. of accum. snow depth | kg/m2 |
| 066 | Snow depth | M |
| 067 | Mixed layer depth | M |
| 068 | Transient thermocline depth | M |
| 069 | Main thermocline depth | M |
| 070 | Main thermocline anomaly | M |
| 071 | Total cloud cover | % |
| 072 | Convective cloud cover | % |
| 073 | Low cloud cover | % |
| 074 | Medium cloud cover | % |
| 075 | High cloud cover | % |
| 076 | Cloud water | kg/m2 |
| 077 | ||
| 078 | Convective snow | kg/m2 |
| 079 | Large scale snow | kg/m2 |
| 080 | Water Temperature | K |
| 081 | Land-sea mask | Fraction |
| (1=land;0=sea) (see note) | ||
| 082 | Deviation of sea level from mean | M |
| 083 | Surface roughness | M |
| 084 | Albedo | % |
| 085 | Soil temperature | K |
| 086 | Soil moisture content | kg/m2 |
| 087 | Vegetation | % |
| 088 | Salinity | kg/kg |
| 089 | Density | kg/m3 |
| 090 | Water run off | kg/m2 |
| 091 | Ice concentration | Fraction |
| (ice=1;no ice=0)(see note) | ||
| 092 | Ice thickness | M |
| 093 | Direction of ice drift | deg. true |
| 094 | Speed of ice drift | m/s |
| 095 | u-component of ice drift | m/s |
| 096 | v-component of ice drift | m/s |
| 097 | Ice growth rate | m/s |
| 098 | Ice divergence | /s |
| 099 | Snow melt | kg/m2 |
| 100 | Significant height of combined wind | m |
| waves and swell | ||
| 101 | Direction of wind waves | deg. true |
| 102 | Significant height of wind waves | m |
| 103 | Mean period of wind waves | s |
| 104 | Direction of swell waves | deg. true |
| 105 | Significant height of swell waves | m |
| 106 | Mean period of swell waves | s |
| 107 | Primary wave direction | deg. true |
| 108 | Primary wave mean period | s |
| 109 | Secondary wave direction | deg. true |
| 110 | Secondary wave mean period | s |
| 111 | Net short-wave radiation (surface) | W/m2 |
| 112 | Net long wave radiation (surface) | W/m2 |
| 113 | Net short-wave radiation (top of atmos.) | W/m2 |
| 114 | Net long wave radiation (top of atmos.) | W/m2 |
| 115 | Long wave radiation | W/m2 |
| 116 | Short wave radiation | W/m2 |
| 117 | Global radiation | W/m2 |
| 118 | ||
| 119 | ||
| 120 | ||
| 121 | Latent heat net flux | W/m2 |
| 122 | Sensible heat net flux | W/m2 |
| 123 | Boundary layer dissipation | W/m2 |
| 124 | Momentum flux, u component | N/m2 |
| 125 | Momentum flux, v component | N/m2 |
| 126 | Wind mixing energy | J |
| 127 | Image data | |
| 128-254 | Reserved for use by originating center) | |
| 255 | Missing |
| Octet 10 - Type of level/layer | Octet 11 - Value 1 | Octet 12 - Value 2 |
| 00 - reserved | ||
| 01 - surface of earth including sea surface | ||
| 02 - cloud base | ||
| 03 - cloud top | ||
| 04 - freezing level (0C) | ||
| 05 - adiabatic condensation level | ||
| 06 - maximum wind level | ||
| 07 - tropopause level | ||
| 08 - nominal top of atmosphere | ||
| 09 - sea bottom | ||
| 10-99 reserved | ||
| 100 - isobaric level | pressure in hectoPascals (hPa) | |
| 101 - layer between two isobaric levels | pressure of top (kPa) | pressure of bottom (kPa) |
| 102 - mean sea level | 0 | 0 |
| 103 - fixed height level above mean sea level (MSL) | height in meters | |
| 104 - layer between two height levels above MSL | height of top (hm) | height of bottom (hm) |
| 105 - fixed height above ground level | height in meters | |
| 106 - layer between two height levels above ground | height of top (hm) | height of bottom (hm) |
| 107 - sigma level | sigma value in 1/10000 | |
| 108 - layer between two sigma levels | value at top in 1/100 | value at bottom in 1/100 |
| 109 - hybrid level | level number | |
| 110 - layer between two hybrid levels | level number of top | level number of bottom |
| 111 - depth below surface | centimeters | |
| 112 - layer between two levels below surface | depth of top (cm) | depth of bottom (cm) |
| 113 - isentropic level | potential temperature (K) | |
| 114 - layer between two isentropic levels | 475-theta of top (K) | 475-theta of bottom (K) |
| 121 - layer between two pressure levels | 1100-pressure of top (hPA) | 1100-pressure of bottom (hPa) |
| 125 - height level | height (cm) | |
| 128 - layer between two sigma levels | 1.1-sigma of top in 1/1000 | 1.1-sigma of bottom in 1/1000 |
| 141 - layer between two pressure levels | pressure of top (kPa) | 1100-pressure of bottom (hPa) |
| 160 - depth below sea level | depth (m) | |
| 200 - entire atmosphere | ||
| 201 - entire ocean |
| VALUE | TIME UNIT |
| 0 | minute |
| 1 | hour |
| 2 | day |
| 3 | month |
| 4 | year |
| 5 | decade |
| 6 | normal (30 years) |
| 7 | century |
| 8-253 | reserved |
| 254 | second |
| VALUE | MEANING |
00 |
Forecast product valid at reference time + P1 P1>0), or uninitialized analysis product for reference time (P1=0) or image product for reference time (P1=0) |
01 |
Initialized analysis product for reference time (P1=0). |
02 |
Product with a valid time ranging between reference time + P1 and reference time + P2 |
03 |
Average (reference time + P1 to reference time + P2) |
04 |
Accumulation (reference time + P1 to reference time + P2). Product considered valid at reference time + P2 |
05 |
Difference(reference time + P2 minus reference time + P1) product considered valid at reference time + P2 |
06-09 |
reserved |
10 |
P1 occupies octets 19 and 20; product valid at reference time + P1 |
11-50 |
reserved |
51 |
Climatological Mean Value: multiple year averages of quantities which are themselves means over some period of time (P2) less than a year. The reference time (R) indicates the date and time of the start of a period of time, given by R to R + P2, over which a mean is formed; N indicates the number of such period-means that are averaged together to form the climatological value, assuming that the N period-mean fields are separated by one year. The reference time indicates the start of the N-year climatology. N is given in octets 22-23 of the PDS. If P1 = 0 then the data averaged in the basic interval P2 are assumed to be continuous, i.e., all available data are simply averaged together. If P1 = 1 (the units of time - octet 18, code table 4 - are not relevant here) then the data averaged together in the basic interval P2 are valid only at the time (hour, minute) given in the reference time, for all the days included in the P2 period. The units of P2 are given by the contents of octet 18 and Table 4. |
52-112 |
reserved |
113 |
Average of N forecasts (or initialized analyses); each product has forecast period of P1 (P1=0 for initialized analyses); products have reference times at intervals of P2, beginning at the given reference time. |
114 |
Accumulation of N forecasts (or initialized analyses); each product has forecast period of P1 (P1=0 for initialized analyses); products have reference times at intervals of P2, beginning at the given reference time. |
115 |
Average of N forecasts, all with the same reference time; the first has a forecast period of P1, the remaining forecasts follow at intervals of P2. |
116 |
Accumulation of N forecasts, all with the same reference time; the first has a forecast period of P1, the remaining follow at intervals of P2. |
117 |
Average of N forecasts, the first has a period of P1, the subsequent ones have forecast periods reduced from the previous one by an interval of P2; the reference time for the first is given in octets 13-17, the subsequent ones have reference times increased from the previous one by an interval of P2. Thus all the forecasts have the same valid time, given by the initial reference time + P1. |
118 |
Temporal variance, or covariance, of N initialized analyses; each product has forecast period P1=0; products have reference times at intervals of P2, beginning at the given reference time. |
119 -122 |
reserved |
123 |
Average of N uninitialized analyses, starting at the reference time, at intervals of P2. |
124 |
Accumulation of N uninitialized analyses, starting at the reference time, at intervals of P2. |
125-254 |
reserved |
| VALUE | MEANING |
| 00 | Latitude/Longitude Grid also called Equidistant Cylindrical or Plate Carree projection grid |
| 01 | Mercator Projection Grid |
| 02 | Gnomonic Projection Grid |
| 03 | Lambert Conformal, secant or tangent, conical or bipolar (normal or oblique) Projection Grid |
| 04 | Gaussian Latitude/Longitude Grid |
| 05 | Polar Stereographic Projection Grid |
| 06-12 | reserved - see Manual on Codes |
| 13 | Oblique Lambert conformal, secant or tangent, conical or bipolar, projection |
| 14 - 49 | reserved - see Manual on Codes |
| 50 | Spherical Harmonic Coefficients |
| 51 - 89 | reserved - see Manual on Codes |
| 90 | Space view perspective or orthographic grid |
| 91 - 254 | reserved - see Manual on Codes |
Bit |
Value |
Meaning |
1 |
0 |
Direction increments not given |
1 |
Direction increments given |
|
2 |
0 |
Earth assumed spherical with radius = 6367.47 km |
1 |
Earth assumed oblate spheroid with size |
|
as determined by IAU in 1965: |
||
6378.160 km, 6356.775 km, f = 1/297.0 |
||
3-4 |
reserved (set to 0) |
|
5 |
0 |
u- and v-components of vector quantities resolved relative to easterly and northerly directions |
1 |
u and v components of vector quantities resolved relative to the defined grid in the direction of increasing x and y (or i and j) coordinates respectively |
|
6-8 |
reserved (set to 0) |
Note: If the GDS is not included in a message then any wind components are assumed to be resolved relative to the grid specified in the PDS with u and v defined as positive in the direction of increasing x and y (or i and j) coordinates respectively.
| BIT | VALUE | MEANING |
| 1 | 0 | Points scan in +i direction |
| 1 | Points scan in -i direction | |
| 2 | 0 | Points scan in -j direction |
| 1 | Points scan in +j direction | |
| 3 | 0 | Adjacent points in i direction are consecutive (FORTRAN: (I,J)) |
| 1 | Adjacent points in j direction are consecutive (FORTRAN: (J,I)) |
Note: i direction is defined as west to east along a parallel of latitude, or left to right along an x axis. j direction is defined as south to north along a meridian of longitude, or bottom to top along a y axis.
| BIT | VALUE | MEANING |
| 1 | 0 | Grid point data |
| 1 | Spherical Harmonic Coefficients | |
| 2 | 0 | Simple packing |
| 1 | Second order ("Complex") Packing | |
| 3 | 0 | Original data were floating point values |
| 1 | Original data were integer values | |
| 4 | 0 | No additional flags at octet 14 |
| 1 | Octet 14 contains flag bits 5 - 12 |
The following gives the meaning of the bits in octet 14 ONLY if bit 4 is set to 1. Otherwise octet 14 contains regular binary data.
| 5 | Reserved (set to 0) | |
| 6 | 0 | Single datum at each grid point |
| 1 | Matrix of values at each grid point | |
| 7 | 0 | No secondary bit maps |
| 1 | Secondary bit maps present | |
| 8 | 0 | Second order values have constant width |
| 1 | Second order values have different widths | |
| 9-12 | Reserved (set to 0) |
Notes:


That day, McGee Brown became the first Black woman on the Supreme Court of Ohio.
“Looking out at that audience at all of those people, I suddenly was taken back to my grandmother,” McGee Brown said. “You realize in that moment that I was there – my getting sworn in was really the manifestation of a lot of hard work by a lot of people I’ll never know or be able to thank who struggled and fought for my ability to be here.”
McGee Brown isn’t an emotional person, but she said the thought of her grandmother, born in the South under Jim Crow laws, brought her to tears.
“And I found myself in that moment, wishing that she were alive to see that, feeling enormous gratitude but also the need to acknowledge that I stood in that place because so many people before me sacrificed,” McGee Brown said.
Long before McGee Brown became the first Black woman justice on Ohio’s Supreme Court in 2011 and judge on the Franklin County Common Pleas Court in 1992, she didn’t know that she would become a lawyer.
“When I was thinking about what I wanted to be as an adult, I just wanted to do something that mattered,” McGee Brown said.
McGee Brown grew up in Columbus and attended Columbus City Public Schools when they were still segregated. Columbus City Public Schools didn’t begin to desegregate until 1977, according to Teaching Columbus.
As a high school student, a guidance counselor brought McGee Brown, and other students, to Ohio University, where she would end up studying journalism and public relations.
“I didn’t have any idea about college,” McGee Brown said. “But there was a really cute guy on campus and I was looking around and I was like, ‘If this is college, I’m in.’ That was the sum total of my college decision.”
Cute boys on campus were a bonus for McGee Brown, but OU is where she grew up from 1978 to 1982. A few women professors and advisors also inspired McGee Brown and guided her to law school. One of these influential people in McGee Brown’s life is Sandra Haggerty. She started working at OU in 1979 and later served as the assistant dean at Scripps College of Communication from 1987-1994.
“She literally changed my life,” McGee Brown said. “At the end of my sophomore year, we started talking about what I’m going to do with this degree. And I told her that I thought I wanted to go to Washington and work for a politician, like I thought I’d be a press secretary on the Hill. And she’s like, ‘Yeah, you should go to law school.’”
After graduating from OU, McGee Brown went to law school at The Ohio State University’s Moritz College of Law. She said she always felt supported as a law student there, but she appreciates OU for helping her grow.
“I think I give OU so much credit for helping me learn to be a leader and they gave me so many opportunities,” McGee Brown said. “I would not be who I am without having spent those four years there.”
hen McGee Brown knew she wanted to do something with her life that mattered, she remembered the words of James Barnes, a former political science professor at OU.
All of us have a sphere of influence,” McGee Brown said. “It can be great or it can be small. But each of us has the ability to impact the world from where we are and grow.”