ursula
time & habits
design to web
emotional intelligence
daily mindfulness
meditation
tech one
tech two
reflections
javascript basics
self confidence
problem solving
control
javascript language
Motivation and Values


This dialog allows you to set the options of a template JUMP element (and its contained element, using the Edit button). It is usually invoked by right-clicking the JUMP node in the template tree view and selecting the "Edit..." item.
A JUMP element allows "out of order" processing of data in a file. This is typically used to handle a "header" at the end of file. It is also useful as a "look ahead" facility as after processing the JUMP element the current file position returns to the position before the JUMP.
A JUMP element does not have a name but takes the name of its contained element, for the purpose of expression evaluation.
Address
An expression used (along with the Relative to field) to determine the new data file address.
Relative to
The new address can be relative to start or end of file or the current position.
Element
This displays the name and/or type of sub-element contained in the JUMP (typically a STRUCT).
Edit
Use this button to edit the element of the JUMP.
Replace with
Use this button to replace the element contained in the JUMP with an element of a different type.
Comments
Add any other relevant information here.
<< and >> buttons
If the parent element is a STRUCT then these buttons are displayed in the bottom right of the dialog. They allow you to move to the previous and next sibling (ie the previous and next elements in the parent STRUCT). This is very handy when you quickly want to view or change values in all the children.
Using the button is equivalent to clicking OK then editing the previous or next element in the parent STRUCT.


If you are the proposer you will decide how to divide up a sum of {0} points between you and your partner.
You may choose to give your partner any amount from 0 to {0} points and you will receive the remaining amount.


# File lib/rfilter/delivery_agent.rb, line 177 def pipe(command, continue = false) log(2, "Action: pipe to #{command.inspect}") deliver_pipe(command, @message) if $? != 0 m = "pipe failed for command #{command.inspect}" log(1, "Error: " + m) raise DeliveryCommandFailure.new(m, $?) end unless continue raise DeliverySuccess.new("pipe to #{command.inspect}") end end


In the Unit Page, the operator can create/update/delete Unit and Unit parameters. The
Unit is actually a representation of a single device, such as a CPE or a mobile
phone. To create a Unit, the operator has to select the appropriate Unit Type and Profile,
and enter the new Unit Id. It is always possible to move an existing Unit from one Profile
to another Profile. If you create a new Unit, then the Unit Id must conform with the protocols
Unit Id format.
For TR-069 this is <OUI>-<Product Class>-<Serialnumber>.
OUI is a 6-digit number identifying the manufacturer of the device. Product Class is a
string identifying the model of the device. SerialNumber is usually the MAC address of the
device.
To delete a particular Unit, find the Unit with the search page. Units cannot be deleted by accident. Whenever the operator click a delete button, the operator will be asked to confirm the delete.
If the Administrator want to upgrade the Unit to another Software version, it is possible to do so from the Links section on the Unit page. The Administrator will get a new window where the desired Software version can be selected from a drop down menu, and by clicking upgrade the upgrade process will begin the next time the unit is provisioned. The Administrator can also change the Unit he wants to upgrade, by typing a part of the Unit id, and he will get a list of Units that matches.
If the operator want to configure Service Window for the Profile, it is possible to do so
from the Links section. After selecting from day [,to day], from and to time and
frequency, clicking "Update service window" will set the correct parameters in the
Unit. These settings will override Profile service windows. The idea of a Service Window
is that you can control when the device will connect to the server. Maybe you only want
provisioning to happen during daytime on working days - that can be specified. But
it might also be that you will specify a lower load on the system, by changing the frequncy
from 7 times pr week (default) to 2 times pr week.
Actually there are two Service Windows: One for the regular/standard provisioning, and one
for provisioning that disrupts the service. If you specify a firmware upgrade or a scheduled
reboot, it is the Disruptive Service Window that decideds when the provisioning will happen,
otherwise it is the Regular Service Window that decides.
Another point worth mentioning about Service Window is "spread". Setting the
frequency to 7 (time pr week), is not to say that the device will connect every 24h. It will
connect *on average* every 24h, but it might vary with many hours either way. This is
to ensure that a power outage in a major city will not cause many devices to cause a peak
in the load of your system.
In the Unit parameters listing, the operator will get a list containing all the Unit
parameters and all the Profile parameters. If a parameter has both a Profile value and a
Unit value, the latter takes precedence over the former. There are in general two types
of parameters: System parameters and Device parameters. The System parameters name is prefixed
"System" and the Device parameters are prefixed "InternetGatewayDevice" or "Device".
The Device parameters can be read or written from the device. If a parameter is a
Read-Only parameter, it can be retrieved from the device - but never written to the device.
A Read-Write parameter can be written to the device, but not read from the device.
So by setting values in the Read-Write parameters you decide what to provision to the
device. For more information about the flags governing the behaviour of a parameter, read
the Unit Type help section.
If the operator needs to configure some SIP parameters, use the filter section to look these up. By default, when no unit parameters are defined, "Status" is set to "All" which means that both "Unconfigured" and "Configured" unit parameters are displayed at the same time. If some unit parameters are configured, then the status will be set "Configured". If SIP parameters is not set and there are other unit parameters configured, you will not be able to see the SIP parameters unless you change "Status" to "All" or "Unconfigured". There are other filters: Name filter (just type part of the parameter name) and type filter (read-only, system parameter, etc). Use this filter to quickly find the parameters you want to examine/edit.
Inspection mode is a possibility only if the unit in question is on public IP (not connected behind a router) and if the protocol in use is TR-069. If that is the case you can connect to it by chaning to Inspection mode. In this mode you can inspect all parameters with the "I" flag set (see Unit Type page). You can also change parameter values on-the-fly and therefore quickly fix any problems that the customer might experience. You can probably achieve the same result on units that doesn't comply to these requirements, but then the customer will need to restart his/her device to get started, possibly also each time you want to perform a change or a new read on the device. All in all, Inspection mode is not very useful at this moment, but future development will make things more convenient.


--- layout: archive title: Zulip Chat Archive permalink: /stream/113489-new-members/topic/lean.20code.20formatter.html ---
I was wondering if there was some tool that would automatically format lean code into a canonical style similar to rustfmt
or gofmt
?
Not in Lean 3.
Lean 4 will make this much easier, so it will probably exist in the not too distant future.
Thanks @Patrick Massot
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


‘By Virtue and Valor, We Shine.’
The Capet Fraternity is a prestigious organization that focuses on developing its members’ understanding of culture and personal grace while simultaneously improving their standing in society.
Our Core Principles
Democracy - We must be free to be ourselves while also being accountable for the consequences of such freedom.
Heritage - We are a product of our past. Let us not forget from whence we came.
Human Rights - People are communal. We were never meant to make this journey alone.


[attributes] --- label: The RubyGems Partnership layout: default target_page: categories: [] is_published: true position: 4 [wysiwyg content]
The Rubygems Partnership is a cooperative effort between Ruby Central and Ruby Together to ensure that RubyGems.org is funded, stable, maintained, and supported.
Ruby Central, organizers of the international RubyConf and RailsConf conferences, own the RubyGems.org service. They underwrite hosting costs and ensure that the service is able to continue long-term without needing any external source of funding.
Ruby Together provides funding and coordination for ongoing development, maintenance, and support work, as well as on-call system administrators. This ensures that the service continues to mature, grow, and improve, as well as ensuring that everything continues to run in tip-top shape.


Complete & included with Haystack.
Complete & included with Haystack.
Complete & included with Haystack.
Complete & available as a third-party download.
| Backend | SearchQuerySet Support | Auto Query Building | More Like This | Term Boost | Faceting | Stored Fields | Highlighting | Spatial |
|---|---|---|---|---|---|---|---|---|
| Solr | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes |
| Elasticsearch | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes |
| Whoosh | Yes | Yes | No | Yes | No | Yes | Yes | No |
| Xapian | Yes | Yes | Yes | Yes | Yes | Yes | Yes (plugin) | No |
The following are search backends that would be nice to have in Haystack but are licensed in a way that prevents them from being officially bundled. If the community expresses interest in any of these, there may be future development.
This backend is unlikely to be built. Sphinx is pretty gimpy & doesn’t do blended search results across all models the way the other engines can. Very limited featureset as well.


LiveView Can Get Messy
As LiveView becomes a more established technology, we naturally find ourselves using it to back more and more complex features. If we’re not careful, this can lead to “fat controller syndrome”––live views that are jam packed with complex business logic and disparate responsibilities, just like the classic “fat Rails controller”.
How can we write live views that are easy to reason about and maintain while adhering to common design principles like SRP?
One way to achieve this goal is to leverage the Phoenix.LiveComponent
behaviour.
Introducing Phoenix.LiveComponent
Components are modules that use the Phoenix.LiveComponent
behaviour. This behaviour provides
…a mechanism to compartmentalize state, markup, and events in LiveView. ––docs
Components are run inside a parent live view process via a call to Phoenix.LiveView.live_component/3
. Since they share a process with their parent live view, communication between the two is simple (more on that later).
Components can be stateless or stateful. While stateless components don’t do much more than render a particular leex
template, stateful components implement a handle_event/3
function that allow us to update the component’s own state. This makes components a great way to peel off responsibilities from an overly complex live view.
Let’s take a look at how we can use components to refactor some complicated LiveView code in an existing application.
The App
Let’s say we have an application that uses a message broker like RabbitMQ to publish and consume messages between systems. Our app persists these messages in the DB and exposes a UI for users to list and search such persisted messages.
We’re using LiveView to enact the search functionality, pagination and maintain which messages are currently being displayed in state. Our live view module responds to search form events and maintains the state of the search form, handles the search form submission and renders the template with various search and pagination params.
The Code
A simplified version of our live view looks something like this:
defmodule RailwayUiWeb.MessageLive.Index do
def render(assigns) do
Phoenix.View.render(RailwayUiWeb.MessageView, "index.html", assigns)
end
def mount(_session, socket) do
socket =
socket
|> assign(:page, 1)
|> assign(:search, %Search{query: nil, value: nil})
|> assign(:messages, load_messages())
{:ok, socket}
end
def handle_params(
%{"page" => page_num, "search" => %{"query" => query, "value" => value}},
_uri,
%{assigns: %{search: search}} = socket
) do
socket =
socket
|> assign(:page, page_num)
|> assign(:search, Search.update(query, value))
|> assign(:messages, messages_search(query, value, page_num))
{:noreply, socket}
end
def handle_params(
%{"page" => page_num},
_uri,
%{assigns: %{state: state}} = socket
) do
socket =
socket
|> assign(:page, page_num)
|> assign(:messages, messages_page(page_num))
{:noreply, socket}
end
def handle_params(
%{"search" => %{"query" => query, "value" => value}},
_,
%{assigns: %{search: search}} = socket
) do
socket =
socket
|> assign(:search, %Search{query: query, value: value})
|> assign(:messages, messages_search(query, value))
{:noreply, socket}
end
def handle_params(_params, _, socket) do
{:noreply, socket}
end
def handle_info("search", params, socket) do
{:noreply,
live_redirect(socket,
to: Routes.live_path(socket, __MODULE__, params)
)}
end
def handle_event(
"search_form_change",
%{"_target" => ["search", "value"], "search" => %{"value" => value}},
%{assigns: %{search: search}} = socket
) do
{:noreply, assign(socket, :search, %Search{query: search.query, value: value})}
end
def handle_event(
"search_form_change",
%{"_target" => ["search", "query"], "search" => %{"query" => query}},
%{assigns: %{search: search}} = socket
) do
{:noreply, assign(socket, :search, %Search{query: query, value: search.value})}
end
def handle_event(
"search_form_change",
%{"_target" => ["search", "query"], "search" => %{"value" => _value}},
socket
) do
{:noreply, socket}
end
end
Maintaining a representation of the search form’s selected query and inputed value in state allows us to ensure that the correct search query radio button is selected and allows us to update the placeholder text of the search form input field:
Maintaining the search form state also ensures that users can navigate directly to the /consumed_messages
route with a set of query params and see not just the correctly populated messages but also the correctly configured search form:
The Problem
Its clear that we need to maintain the state of our search form but the LiveView code above is too lengthy to maintain and reason about. It manages search form state, implements a set of handle_params/3
callbacks to enact search queries and pagination and maintains a set of messages in state. This is a lot of work and it violates the Single Responsibility Principle. Our live view, plainly put, does too many jobs.
Let’s refactor the search form state maintenance into its very own stateful component!
The Solution: The Search Form Component
Our search form component will get its initial search form state from the parent live view. This will ensure that a user can navigate directly to a route like /consumed_messages?search[query]=uuid&search[value]=0af71c6a-aeec-431f-83d0-ae779358b055
and see the search form correctly configured from the params.
However, our search component will go on to maintain the search form state independently of the parent, only forwarding messages up to the live view when the form is submitted.
This way, we can move the search form change event handling and its subsequent impact on search form state out of the live view. This will leave us with a cleaner live view with fewer responsibilities.
Defining the Component
Setting Initial State From LiveView
We’ll begin by defining our component, RailwayUiWeb.MessageLive.SearchComponent
, and rendering it with an initial search from state from the parent live view.
defmodule RailwayUiWeb.MessageLive.SearchComponent do
use Phoenix.LiveComponent
def render(assigns) do
Phoenix.View.render(RailwayUiWeb.MessageView, "search_component.html", assigns)
end
end
At this point, our component is simple. It uses the Phoenix.LiveComponent
behaviour and implements a render/1
function. This function renders our search_component.html.leex
template (which we’ll take a look at in a moment), passing through the assigns
established when the parent live view calls live_component/3
.
Let’s take a look at that call now. In the parent live view’s template, we invoke:
<%= live_component @socket, RailwayUiWeb.MessageLive.SearchComponent, search: @search, id: :search %>
There are two important things to call out here. First, its important to note that we are passing in the :id
attribute and setting it to a value of the :search
atom. Components are made stateful by the setting of the :id
attribute. Without this, we would not be able to implement the handle_event/2
callbacks
Second, we are populating the component’s assigns
with the @search
value. The component’s assigns
at this point looks like this:
%{search: search}
And the search struct from the parent live view’s socket.assigns
will be available in the component’s own template as @search
.
This allows us to leverage the handle_params/3
callback in the parent live view to establish the search state and then pass that search state into the component. Let’s take a closer look at how this works:
- User visit
/consumed_messages?search[query]=uuid&search[value]=0af71c6a-aeec-431f-83d0-ae779358b055
- The
MessageLive.Index
live view’shandle_params/3
function is called:
def handle_params(
%{"search" => %{"query" => query, "value" => value}},
_,
%{assigns: %{search: search}} = socket
) do
socket =
socket
|> assign(:search, %Search{query: query, value: value})
|> assign(:messages, messages_search(query, value))
{:noreply, socket}
end
- The
MessageLive.Index
live view’s template renders with the@search
assignment - The
MessageLive.Index
’s template callslive_component/3
, passing through the@search
assignment - The
MessageLive.SearchComponent
’s template renders with the@search
assignment, correctly rendering the search form to reflect any selected search query type and input.
Let’s take a look at the component’s template now in order to understand how it uses the information in the search form’s state to render appropriately.
Building The Search Form Template
The search component’s template uses the query and value attributes of the @search
assignment to ensure that the correct radio button is selected and that the search form input is correctly populated with a value if one is present.

<form>

<input name="search[query]" value="uuid" type="radio" <%= if @search.query == "uuid", do: "checked" %>>
message UUID

<input name="search[query]" value="correlation_id" type="radio" <%= if @search.query == "correlation_id", do: "checked" %>>
correlation ID

<input name="search[query]" value="message_type" type="radio" <%= if @search.query == "message_type", do: "checked" %>>
message type

<input name="search[value]" value="<%= @search.value %>" type="text" placeholder="<%= "search by<EMAIL_ADDRESS>%>">

<button type="submit" class="btn btn-primary">Submit</button>
</form>
A few things to note here:
if
conditions, like the one below, are responsible for ensuring the correct radio button is selected:
if @search.query == "message_type", do: "checked"
- The
value
of the search form’s input field is populated by the@search
assignment’svalue
attribute:
Now that we’ve seen how our component is rendered with its initial search form state, let’s take a look at how our component will handle search form events.
Handling Form Change Events
We need to update the component’s socket.assigns
to reflect changes to search form state under two conditions:
- The user selects a given search query (“message UUID”, “correlation ID”, “message type”)
- The user types a value into the search form input field
We’ll add a phx-change
event to our form to capture these interactions and define the corresponding handle_event/3
callbacks in our component.
<form phx-change="search_form_change">
...
</form>
We’ll add the following handle_event/3
callbacks:
defmodule RailwayUiWeb.MessageLive.SearchComponent do
...
# update search state when user inputs a search value
def handle_event(
"search_form_change",
%{"_target" => ["search", "value"], "search" => %{"value" => value}},
%{assigns: %{search: search}} = socket
) do
{:noreply, assign(socket, :search, %Search{query: search.query, value: value})}
end
# update search state when user selects a query type radio button
def handle_event(
"search_form_change",
%{"_target" => ["search", "query"], "search" => %{"query" => query}},
%{assigns: %{search: search}} = socket
) do
{:noreply, assign(socket, :search, %Search{query: query, value: search.value})}
end
end
These callbacks ensure two things for us:
- The correct radio button is marked as “selected” when a user chooses a new search query type option.
- The search form input’s
placeholder
attribute is correctly updated to reflect the selected query type:
<input name="search[value]" value="<%= @search.value %>" type="text" placeholder="<%= "search by<EMAIL_ADDRESS>%>">
Handling Form Submission
Now that our form component’s state properly updates in response to the user’s interactions, let’s talk about what needs to happen when a user submits the form.
The feature we’re designing requires us to populate the URI’s query params in the browser’s URL bar when the user submits the search form. This allows users to share a link with the results of a particular search.
In order to achieve this, we can reach for the live_redirect/2
function. This will take advantage of the browser’s pushState
API to change the page navigation without actually sending a web request. Instead, our live view’s handle_params/3
callback function will be invoked, allowing us to respond by searching for the appropriate messages and updating the live view socket’s state with those messages.
But wait! The live_redirect/2
function is sadly not available from within component since the Phoenix.LiveComponent
behaviour does not implement a handle_params/3
function. Luckily for us, however, the parent live view and the component share a process. That means that calling self()
from within the component returns a PID that is the same PID as that parent live view process. So, from within our component we can send
a message to self()
and handle that message in the parent live view.
We’ll take advantage of this functionality to have our component handle search from submission events by sending a message to the parent live view instructing that live view to enact a live redirect.
We’ll start by adding a phx-submit
event binding to our search form in the component’s template:
<form phx-submit="search" phx-change="search_form_change">
...
</form>
Then we’ll implement a handle_event/3
function for this "search"
event in the component:
defmodule RailwayUiWeb.MessageLive.SearchComponent do
...
def handle_event("search", params, socket) do
send self(), {:search, params}
{:noreply, socket}
end
end
The important part of our function is this line:
send self(), {:search, params}
Here, we are sending a message {:search, params}
that the parent live view can respond to.
Lastly, we will implement a handle_info/2
callback in the parent live view that will be responsible for enacting the live redirect with the params from the search form:
defmodule RailwayUiWeb.MessageLive.Index do
...
def handle_info({:search, params}, socket) do
{:noreply,
live_redirect(socket,
to: Routes.live_path(socket, __MODULE__, params)
)}
end
end
This will in turn cause the live view’s handle_params/3
callback to be invoked, resulting in the correct updates to the live view’s state:
defmodule RailwayUiWeb.MessageLive.Index do
...
def handle_params(
%{"search" => %{"query" => query, "value" => value}},
_,
%{assigns: %{search: search}} = socket
) do
socket =
socket
|> assign(:search, %Search{query: query, value: value})
|> assign(:messages, messages_search(query, value))
{:noreply, socket}
end
end
Conclusion
As a result of this refactoring, we have a cleaner live view module that is more adherent to the Single Responsibility Principle. Our live view can focus on setting up the correct state given a set of params. Meanwhile, the logic required to maintain the state of the search form and render search form attributes appropriately can be housed in a dedicated component.
We did run into an obstacle when we found ourselves unable to use live_redirect/2
from within our component. However, since the component and the live view share a process, we found it easy to enact communication between the two.
Still, this approach doesn’t allow us to build a live view that is entirely agnostic of the state of the search form. In order to allow users to navigate directly to the route with query params, our parent live view does set up the initial state of the search form and pass it down into the component. Regardless of this drawback, reaching for components here has allowed us to write and maintain a slimmer live view.
For a look at some of the other state, markup and event handling isolation options that LiveView offers, check out the docs here.
Caught a mistake or want to contribute to the article? Edit this page on GitHub!


Library
DOWNLOADING FILE...


Ultra form
First Name
Last Name
Birthday
Birthday
Sex
Mr
Mrs
Country
Country
Ukraine
France
Great Britain
USA
Switzerland
Email
Password
Address
Notes
Submit
Congrats. Your form is Valid!
Got It!


Hello World Body - with extra text
This is line one and will be pushed to GitHub at a branch level.
Line being added within NewRemoteLocalFlowDemo branch.


MEMEIFY MARVEL
VIEW MEMES
CREATE MEMES
TITLE:
Select An Image
Select An Image
Select An Image
Select An Image
MEMEIFY
CLEAR
IRONMAN
THOR
HULK
CAPTAIN AMERICA


Age Calculator
Calculates age based on Date of Birth
Web Developer
I strive to create visually appealing sites that feature user-friendly design and clear navigation.
Age Calculator
Calculates age based on Date of Birth
Mad Libs
Word game
Choose Adventure
Choose your own adventure
Mohjong
Tile based game
Roman Numeral Converter
Convert numbers into Roman numerals
Roman numerals are a numeral system that originated in ancient Rome and remained the usual way of writing numbers throughout Europe well into the Late Middle Ages. Numbers in this system are represented by combinations of letters from the Latin alphabet.
Yahtzee
Five 6-sided dice game
The objective of the game is to score points by rolling five dice to make certain combinations. The dice can be rolled up to three times in a turn to try to make various scoring combinations and dice must remain in the box. A game consists of thirteen rounds. After each round the player chooses which scoring category is to be used for that round. Once a category has been used in the game, it cannot be used again. The scoring categories have varying point values, some of which are fixed values and others for which the score depends on the value of the dice. A Yahtzee is five-of-a-kind and scores 50 points, the highest of any category. The winner is the player who scores the most points.
Hanjie
Puzzle game
A Hanjie puzzle consists of a rectangular grid with one or more clues for each row and column of the puzzle. Clues for each row are at the left of the puzzle; clues for columns are at the top.
2048
Sliding block puzzle game
2048 is a single-player sliding block puzzle game. The objective of the game is to slide numbered tiles on a grid to combine them to create a tile with the number 2048.
Pomodoro
Time management system
The Pomodoro Technique uses a timer to break down work into intervals, traditionally 25 minutes in length, separated by short breaks.
To do list
Tasks priority list
A to-do list app lets you do all that much more efficiently, dragging and dropping tasks to reorder them, changing a priority or due date with one click, attaching a note to a task with additional thoughts.


set shp <-type> <-fmt n m > fnameroot
Sets the filename root for shapefile output and has additional arguments to control the type of shapefile created and the formatting of numerical values in the dBase file. This command is used in conjunction with set gxout shp
and display
to create four complementary files:
fnameroot.shp
The main binary file in which each record describes a shape with a list of vertices (default is grads.shp
)
fnameroot.shx
The index file contains the offsets for each record in the main file (default is grads.shx
)
fnameroot.dbf
A dBase table that contains feature attributes for each record in the main file (default is grads.dbf
)
fnameroot.prj
A text file that describes the default projection: the WGS84 lon-lat spheroid (default is grads.prj
)
Where type
may be one of the following:
ln | line
(default) Shapefile output will contain shapes of the type PolyLineM (measured contour lines)
pt | point
Shapefile output will contain shapes of the type PointM (measured points)
poly
Shapefile output will contain polygons of the type PolygonM (measured polygons)
-fmt n m
Optional controls for the formatting of the numerical values in the dBase file.
n
is the maximum number of digits to be used when formatting integers and doubles in the data base entry (default is 12)
m
is the number of precsion decimal places to be used when formatting doubles in the data base entry (default is 6)
Both m
and n must be provided when using the -fmt option
This command is available in GrADS v2.0.a9 or later. The -poly option is available in version 2.0.0 or later.
The files fnameroot.*
will be replaced if they exist.
When creating a shapefile with contour lines, the cterp
setting is ignored -- contours are written out as if cterp
is set to off
(i.e. no spline fitting).
Use the q shpopts
command to get information on the status of the shapefile options; use the clear shp
command to reset shapefile options to their default values.
The output in shapefile format is intended for use with GIS tools, and can also be drawn with GrADS. Please see the documentation page on shapefiles for more information.
set gxout shp
set shp -ln -fmt 8 3 my_shapefile_name
d my_var
set shp -poly mypolyfile
set shpattr author string your_name
d my_var
Note: The GrADS expression my_var
must be a 2-dimensional grid that varies in X and Y (longitude and latitude). In this example, GrADS will use the format string %8.3f
to write out double precision numbers to the dBase file.


Here you can find friends or stalk strangers. This site will enable you to get to know me and my friends.


public class ObjectPool<T extends ObjectPool.Poolable>
extends java.lang.Object
| Modifier and Type | Class and Description |
|---|---|
static class |
ObjectPool.Poolable |
| Modifier and Type | Method and Description |
|---|---|
static ObjectPool |
create(int withCapacity,
ObjectPool.Poolable object)
Returns an ObjectPool instance, of a given starting capacity, that recycles instances of a given Poolable object.
|
T |
get()
Returns an instance of Poolable.
|
int |
getPoolCapacity()
Returns the capacity of this object pool.
|
int |
getPoolCount()
Returns the number of objects remaining in the pool, for diagnostic purposes.
|
int |
getPoolId()
Returns the id of the given pool instance.
|
float |
getReplenishPercentage() |
void |
recycle(java.util.List<T> objects)
Recycle a List of Poolables that this pool is capable of generating.
|
void |
recycle(T object)
Recycle an instance of Poolable that this pool is capable of generating.
|
void |
setReplenishPercentage(float percentage)
Set the percentage of the pool to replenish on empty.
|
public int getPoolId()
public static ObjectPool create(int withCapacity, ObjectPool.Poolable object)
withCapacity
- A positive integer value.object
- An instance of the object that the pool should recycle.public void setReplenishPercentage(float percentage)
percentage
- a value between 0 and 1, representing the percentage of the pool to replenish.public float getReplenishPercentage()
public T get()
public void recycle(T object)
object
- An object of type T to recyclepublic void recycle(java.util.List<T> objects)
objects
- A list of objects of type T to recyclepublic int getPoolCapacity()
public int getPoolCount()


As many of you already know, there is a new mailing list for the course<EMAIL_ADDRESS>It is a private mailing list: only the members can read and write messages
For subscribing to the mailing list, one has to send me an e-mail<EMAIL_ADDRESS>asking for it, and I'll add him/her directly to the list
The old mailing list will be closed in a few days
There are no further communications
He was an Argentine short-story writer, poet, and essayist
He produced several works laying between philosophical literature and fantasy genre
Main topics of his works: dreams, labyrinths, libraries, mirrors, the notion of infinity, and religions
Big library, made of hexagonal rooms
20 bookshelves in four of the walls of each room (5 bookshelves per wall)
Each bookshelf contains 35 books
Each book counts 410 pages
Each page organised in 40 lines
Each line contains 80 characters
The library contains all the books that have been and will be written by using every possible combination of 25 basic characters: 22 letters, the period, the comma, and the space
Opening sentence: [the Library] is composed of an indefinite and perhaps infinite number of hexagonal galleries
The narrator suggests that the library is made of an infinite number of books, contained in an infinite number of rooms – however, is really this the case?
Mathematical infinity exists, it is an abstract concept: the set of all the prime numbers, which is an infinitive set
Often we refer to an infinite amount of something when actually we are speaking about a quite extensive and huge mass of stuff
It contains only 2*101834097 of books
That number has been obtained by considering all the possible combination of all the finite set of charaters in all the 410 pages in all the books that can be generated
In existing computational systems (e.g. an electronic computer), we must be aware that infinity (e.g. the tape of a Turing Machine) is an illusion
A set is a countable sequence of unordered and non-repeatable elements
Countable: it is possible to know the length of the set (i.e. how many elements it contains) – in ThyMopani, we can use the support algorithm def len(countable_object)
Unordered: the elements are placed in the set without any particular order
Unrepeatable: the elements cannot appear more than one time in the set
Create a new set: set()
Add new element: <set>.add(<element>)
Remove element: <set>.remove(<element>)
Add elements from another set: <set>.update(<another_set>)
my_first_set = set() my_first_set.add(34) my_first_set.add(15) my_first_set.add("Silvio") my_first_set.remove(34) my_first_set.update(my_first_set)
my_first_set =
34
15
"Silvio"
A dictionary is a countable collection of unordered key-value pairs, where the key is non-repeatable in the dictionary
Unrepeatability of keys: the same key cannot be included twice in the dictionary
Create a new dictionary: dict()
Add new pair: <dictionary>[<key>] = <value>
Remove a pair: del <dictionary>[<key>]
Get value by key: <dictionary>.get(<key>)
Add pairs from another dictionary: <dictionary>.update(<another_dictionary>)
my_first_dictionary = dict() my_first_dictionary["age"] = 34 my_first_dictionary["day of birth"] = 15 my_first_dictionary["name"] = "Silvio" del my_first_dictionary["age"] my_first_dictionary.update(my_first_dictionary) my_first_dictionary.get("name")
my_first_dictionary =


[GSoC 2016] Progress on External runtime functions
After the codebase merge a lot of new tasks and issues turned up. One of the important tasks is adding runtime support for externally defined functions in Prelude. I have made a complete list of unimplemented External functions and their priorities. Current status of this module can be found here.
Before this task I also worked on making a more robust test suite in ruby. All tests can be run using the rake test
command and in order to force recompile all intermediate files from scratch for testing, the command rake ftest
can be used.
I am currently working of refactoring expressions.rb to facilitate the definition of some External functions.
The complete list of upcoming tasks can be found here.


You keep hearing about this composition API in Vue. But it's a little scary and intimidating, and why it's so much better isn't really all that clear to you.
In this article you'll see exactly why you should learn to use it by comparing the old way to the new way. The examples also start out simple and get more complex, so you can see that the composition API isn't really all that different from what you're used to.
This replaces Vue 2's current options API, but the good news is that you aren't required to use it in Vue 3 applications. You can still use the tried-and-true options API and write your components just like you would have previously in Vue 2. For those who want to adopt this new method now or just want to familiarize with the updates, here's a few examples of some common, simple components, re-written using Vue 3's composition API.
A simple counter
Pretty much the go-to "Hello world" of frontend frameworks, the counter component. Let's see what one looks like in Vue 2:
<template>

{{ counter }}
<button @click="counter += 1">+1</button>
<button @click="counter -= 1">-1</button>

</template>

We're displaying a span tag with a counter data object, which starts at zero. We then have two buttons with v-on:click
attributes and inline code telling them to increase, or decrease, the counter by one. Then in the script tag, we're initializing that counter through a returned object in the data method.
Now let's take a look at what the same component looks like in Vue 3:
<template>
{{ counter }}
<button @click="counter += 1">+1</button>
<button @click="counter -= 1">-1</button>
</template>

The first thing you might notice is that I've removed that wrapper div from the template. Previously in Vue, you'd get an error if you tried to render a component with more than one top-level element under the template tag. In Vue 3, this is no longer the case!
Moving down to the script section, it's a little longer than the previous component. That's kind of to be expected though, since our functionality is the bare minimum and there's slightly more setup with the composition API. Let's go over the changes line-by-line.
import { ref } from 'vue';
The ref
method is required in order to give any data point reactivity in the composition API. By default, variables returned from the setup
method are not reactive.
export default {
setup() { ... }
}
Next, we have the new setup
method. This is the entrypoint for all composition API components, and anything in the returned object from it will be exposed to the rest of our component. This includes things like computed properties, data objects, methods, and component lifecycle hooks.
setup() {
const counter = ref(0);
return {
counter
};
}
We're first creating a counter using the previously-mentioned ref
method, and passing it the initial value, zero. Then, all we have to do is return that counter, wrapped in an object.
From there, our component works just like it previously did, displaying the current value and allowing the user to adjust it based on the button presses given! Let's move on and take a look at something with a little more moving parts.
A shopping cart
Moving up in complexity, we'll create a component that uses two common attributes in Vue, computed properties and defined methods. I think a great example for that would be a basic shopping cart component, which shows items that a user has selected on something like an e-commerce website.
Here's an example of that in Vue 2 using the options API:
<template>

{{ item.name }}
{{ item.quantity }}
{{ item.price * item.quantity }}
<button @click="removeItem(index)">Remove</button>

Total: {{ cartTotal }}

</template>

Items in the cart are listed with v-for
, and a button is present after each one to remove it from the main array on click. The total cost of the cart is calculated through a computed property that uses reduce
and the value is displayed at the bottom of the items. Pretty straightforward, I think!
Let's see what a similar component with these attributes looks like in Vue 3 using the composition API:
<template>

{{ item.name }}
{{ item.quantity }}
{{ item.price * item.quantity }}
<button @click="removeItem(index)">Remove</button>

Total: {{ cartTotal }}

</template>

The biggest difference is that the computed property and method aren't in their own properties in the root Vue object, instead they're just plain methods defined and returned in the main setup()
method.
For methods, we just create them as functions:
const removeItem = (index) => {
items.value.splice(index, 1);
};
And as long as we include them in the returned object, they're exposed to (and can be used by) the rest of the component. Computed properties are almost the exact same, with the exception of being wrapped in a computed
method that's imported from the main Vue package:
const cartTotal = computed(() => {
return items.value.reduce((total, item) => {
return total += (item.price * item.quantity);
}, 0);
});
This way, we can de-couple parts of our components and separate them even further into portions of functionality that can be re-used and imported into multiple other components. We'll see how to do this in our next example.
For instance, if we wanted to, we could easily split out the cartTotal
computed property or the removeItem
method into their own files. Then instead of defining and using them in the main component above, we'd import them and just call the designated method.
On to the last component!
A like button
Our third and final example is even more complex than the last two, let's see what a component would look like that has to pull in data from an API endpoint and react to user input.
This is what that might look like with the options API in a Vue 2 application:
<template>
<button @click="sendLike" :disabled="isDisabled">{{ likesAmount }}</button>
</template>

A little more complicated than our previous examples, but let's break it down.
We're starting off in the template with a button, that has a v-on:click
bind to a sendLike
method, and a bound disabled attribute to the data attribute isDisabled
. Inside of that button we're showing the amount of likes with a likes
data attribute.
Moving through to the script, we're initializing the data object returned with 0 likes
, and isDisabled
set to false. We're using the mounted()
lifecycle method to call an API endpoint and set the amount of likes to a specific post's likes.
Then we define a sendLike
method, which disables the button and increases the likes by 1. (We're increasing the likes before actually sending the request so that our user interaction is recorded immediately.)
Finally, we send the request to our make-believe API, and await the response. Either way, we remove the disabled attribute from the button, but if the server returns an error for some reason, we remove the initial like that was recorded and reset likes
to the previous value.
Now, let's see what a similar component would look like in Vue 3 using the composition API:
<template>
<button @click="sendLike" :disabled="isDisabled">{{ likesAmount }}</button>
</template>

Alright, there it is!
Now, a main difference between this and our counter component is the addition of a mounted lifecycle hook. Instead of being another separate method like in Vue 2's options API, this is again just written as a function in setup
, wrapped in an included onMounted()
method.
This is where the composition API can start to shine with composables. This like button component is getting a little long, and it includes some functionality that could be split out into a separate file and imported instead.
For example, we might want to include the retrieval and updating of likes in different components, so we can create a new JavaScript file which handles just that:
// useLikes.js
import { ref, computed, onMounted } from 'vue';
export default function useLikes(postId) {
const likes = ref(0);
const likesAmount = computed(() => {
return likes + ' people have liked this'
});
onMounted(() => {
fetch(`/api/posts/${postId}`)
.then((response) => response.json())
.then((data) => {
likes.value = data.post.likes;
});
});
return {
likes,
likesAmount
}
}
This renderless component, useLikes
, initiates the placeholder likes amount, 0. It then sends a fetch request to the API endpoint of the post whose ID is passed in. After that completes, our likes are then updated to match whatever is attributed to that current post.
So, how's this used back in our main component? Like this:
<template>
<button @click="sendLike" :disabled="isDisabled">{{ likesAmount }}</button>
</template>

First we use an import statement to get our exported useLikes
function, and then use a destructured object that consists of the likes and likesAmount ref object and method respectively. They're brought into our main component through that same useLikes
function.
All that was left to do was pass in the postId
attribute, which we've set as a hard-coded value to 1.
Wrapping up
Well, there you have it! You've seen three different components that were created in Vue 2, and then their counterparts replicated in Vue 3.
Whether you're a developer experienced in the framework, or one who's still learning the ropes, I hope these helped you on your journey through this newest version of Vue. Despite its different, sometimes intimidating appearance, the composition API can help you organize and refactor your frontend code in a more stable and maintainable way.
If you have any questions, comments, or want to chat more about web development in general, don’t hesitate to reach out on Twitter!


POST GRADUATES
| Id | {{element.id | number : fractionsize}} | Full Name | {{element.full_name | titlecase}} | Gender | {{element.gender | titlecase}} | Phone | {{element.phone}} | Academic Department | {{element.Acadamic_department | titlecase}} | Graduation Year | {{element.graduation_year | titlecase}} | Created At | {{element.created_at | date :'fullDate'}} | Updated At | {{element.updated_at | date :'fullDate'}} | Action |
|---|


Three women killed in accident
by Special CorrespondentThree women were killed in an accident near Thoppur here on Monday.
The victims from Thirupattur were on their way to Tiruppur in a car when a lorry rammed it from the rear side. Sathyavani (65), Anbumani (58) and Kavitha (46) died on the spot.
The driver was admitted to the Dharmapuri government medical college hospital with critical injuries.


Services
Audio
Every event is unique and will have its own set of audio challenges. Whether you require flyable speaker systems, on-stage monitor systems, feeds for media and broadcast, or clear audio for your CEO's address -- we have the experience and inventory to cover all of your audio needs and can design a system to meet the specifics of your event.
- State-of-the-art equipment by Digidesign, Yamaha, Midas, EAW, Klarkteknik, and others
- Line Array / Flyable speaker systems
- Distributed speaker systems
- Digital and Analog Consoles
- Wireless, hard-wired, podium, band, and shotgun mic systems
- Monitor systems
- A FULL staff of audio engineers who can't wait to mix your next event
Lighting
Whether lighting is used for setting moods or to showcase an important part of your event, it is one element of an event that people always remember. We carry a wide range of lighting and rigging products including truss systems, chain motors, conventional and moving lights, dimmer rack systems, uplighting and pinspots. Our lighting team will help you design the look you are after. We also make custom gobos (your organization's logo etched in metal or glass) to project on walls or set pieces.
- Moving light fixtures
- Source four fixtures
- PAR lighting
- Genie towers
- Trussing
- Pipe & Base
- Pinspots
- DJ lights / mirror balls
- Lighting controllers
Video
Video is a critical tool when you are trying to get your message across. Whether you need to project your Powerpoint presentation for a meeting, provide an IMAG to an audience of several thousand people, or create a visual sensation for the audience -- our visual personnel have the experience and creativity when putting together your video production. As with all of the production elements, we custom design your video system to best meet the needs of your particular event.
- IMAG (Image Magnification)
- Projection
- Multi-Camera shoots
- Video recording
- Post Production Video Editing
- Webcasting
- Video Display Monitors
- LCD &DLP Projectors 1,500 to 20,000 lumens
- Switchers
Staging
Sometimes staging is the element that defines an event. We carry a wide range of staging to meet any application including: Modular or mobile stages, roofing systems, and hard sets. Our modular stages can be carpeted or covered with a variety of surfaces. We also carry an extensive inventory of pipe & drape and soft goods.
- Stage Set
- Backdrops
- Pipe & Drape
- Podiums
- Generators
- Power distribution systems
- Yellow Jackets
- Speaker Scaffolding
- Dance Floors


| Parameter Notation |
| Character |
Multiple values |
Range |
Default |
Description |
| a |
yes |
integers >0 |
1 |
moving average filter
order, when smoothing the time series for the detection of turning
points |
| b |
yes |
integers >0 |
0 |
number of bins when
partitioning the time series range, if b=0 then it is determined by the
criterion b=sqrt(n) |
| c |
yes |
[0, 1] |
0.5 |
correlation sum, for
finding the radius given the correlation sum. |
| e |
no |
integer
≥ 2 |
10 |
escape factor, for
assessing the false nearest neighbors |
| f |
no |
[0.1, 0.9] |
0.5 |
fraction for the test
set, e.g. f=0.3 indicates that the test set is 0.3 times the time series
length |
| g |
no |
integer
≥ 0 |
0 |
Theiler's window, to
exclude temporally correlated points from the set of neighboring points |
| h |
no |
integers >0 |
1 |
lead time for fitting
and prediction |
| k |
yes |
integers >0 |
1 |
number of nearest
neighbors |
| l |
no |
[0, 0.5] |
multiple cases |
lower band frequency,
for the computation of energy in frequency bands (assuming that the
sampling frequency is one) |
| m |
yes |
integers >0 |
1 |
embedding dimension or
AR model order |
| o |
no |
integers
≥ 10 |
100 |
number of radii for the
computation of the correlation sum in the correlation dimension
estimation, low resolution
(small 'o' facilitates the computation at the cost of accuracy) |
| p |
yes |
integers >0 |
1 |
order of the moving
average part in ARMA |
| q |
no |
integer
≥ 0 |
0 |
truncation parameters,
q=0 for local average map, q<m for PCR solution of the local linear
model parameters, q=m for standard OLS solution of the local linear
model parameters |
| r |
yes |
[0, 1] |
0.1 |
radius for the
computation of the correlation sum (the time series is standardized in
[0,1]). |
| s |
yes |
integers >0 |
4 |
upper/lower ratio of scaling window,
i.e. s=r2/r1, where r2-r1 is the length of the scaling window |
| t |
yes |
integers >0 |
1 |
delay |
| u |
no |
[0, 0.5] |
multiple cases |
upper band frequency,
for the computation of energy in frequency bands (assuming that the
sampling frequency is one). Note that it should hold u>l. |
| w |
yes |
integers >0 |
1 |
offset for the local
window, the local window has length 2*w+1 and it is used for the
detection of turning points |


Please enable JS
Home
About
Portfolio
Resume
Contact
Contact
home
/
contact
Address
Brooklyn, New York
Email
<EMAIL_ADDRESS>Call
(347)-834-1580
Leave a message
Success!
Your message has been sent to us.
Error!
There was an error sending your message.


Measure
Enable
Disable
Euclidean
Equirectangular
Haversine
Clear
Base layer
OSM
Bing
Bing (no labels)
Path draw options
No points
Endpoints
All points
Set resolution
Heatmap options
Set radius
Set blur
Enable coord
Disable coord
Set player speed
Clear
Refresh


WITNESS LIST Appropriations Committee March 17, 2005-7:00A Budget For: Fette, Claudette (Self and Denton County Federation of Families) Loving, Don (Communities in Schools of Texas, Inc and Communities in Schools - Central Texas) Oneal, Krystal (Self) On: Hawkins, Albert (Health and Human Services Commission) Neal, Loyd (City of Corpus Christi) Raab, Ted Melina (Texas Federation of Teachers) Scott, Robert (Texas Education Agency)


I'm not an avid drug user, but I came across a few Ambien, 10mg pills at my friends house the last time I was over. His mother is prescribed them for chronic insomnia which I truthfully have also, however, I decided to recreationally take 25mg. Since no one else has written up an experience as it happens with Ambien, I figured I'd give it a shot.
Current settings:
- Stomach contents: Empty.
- Time: Night (12:33am)
- Setting: Room inside of parents house.
- Usage: First time.
- Mood: Calm.
- No other substances have been injested to alter the effects of the drug.
12:34:
I've injested two and a half pills, which equates to roughly 25mg with about 3oz of water. A few seconds after taking the two and a half pills, I feel an immediate but very small sense of relaxation coming over me.
12:47:
I am begining to feel my limbs getting more and more relaxed and a state of peacefulness coming over my body and mind.
1:03:
I feel the effects setting much stronger now. I keep having thoughts of people talking in a room, but not the same room I am in. I will try and explain. I cannot see 'the people' like you would see visual hallucinations with shrooms or DMT. I see them somewhat in my head, only I have my eyes open. Kind of like a subconcious vision.  I'm also experiencing bionocular vision.
1:17:
I feel very tired right now, but I will try and remain awake. It took me about five minutes to type this line because the keys on the keyboard seem so close to me and I cannot control my finger movement properly. Right now I feel like I'm drunk, although in my personal opinion, I have a lot more control over myself when I'm drunk. I've never fallen down while intoxicated on alcohol. I've fallen twice now mearly by standing up. I can't imagine what it would be like trying to drive.
1:39:
For me, the drug is peaking right now. I'm having a very hard time thinking and I'm experiencing amnesia. I'm seeing small specks of light flashing in my peripheral vision and I'm also experiencing a rather interesting state of mental confusion. I keep asking myself what I am. And answering the question is slowed and a challenge. The feeling I'm having in my head is rather awkward, it's as if someone is behind me and pressing on the side of my head directly to the left and right of my ears. It's not painful, but almost a numbness that races through my body, but does not remain in any location for an extended period of time.
Everything also seems surreal as well. I know that the lamps I have on my table have been there for years, but they seem so interesting now. I can't help but stare at them for extended periods of time, expecting them to say something or maybe move. I'm seeing people laughing now in my 'head'. My eyes are still open, but I can see them in sort of a greyish blue color. Sort of like what you see when you close your eyes and try to sleep. I do not hear anything they are saying however, I am talking to myself as well as 'them' trying to imagine what they are talking about. I'm trying to converse with them, even though I have not been directly asked a question or even looked at. It seems like I'm inside of a room where I cannot be seen or heard, but I can see everything these 'people' are doing.
1:51:
I've got a small headache and my balance and quordination are still off. I got up to go to the bathroom and I fell down again. It's a lot different than alcohol because I know when I get up after drinking heavily, I'm going to stumble about in a stupor. With Ambien, it's a total surprise. I can be sitting down feeling in total control and then stand up and fall without warning.
2:13:
I've decided to lay down now. I'm very tired due to the drugs, and due to the fact that it's now 2:00am.
The next day, 11:28:
I've awoke to a normal state of mind, no drug induced 'hangover' and no tiredness or mental confusion like the effects of waking up after taking a large sum of benzodiazepines. Although I do not remember what I dreamed about or if I even dreamed at all. I will try this drug again should I come across it.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


start pollen server, local client only! raco pollen start --local
Note, you can enter a different port number:
Go to browser an open dashboard
http://localhost:<port>/index.ptree
Click on the file name hello.txt on the list
to preview the rendered text file.
Click the link "in" to preview the source code
Lozenge character is used for pollen commands
to be executed, embedded within the text.
Use editor vim in the terminal selecting
the Lozenge-character from Edit menu emoj & symbols


At work, our "Fun Team" decided to play the "Two Truths and a Lie" game.
Below is a slight modification of what I submitted:
- In college, PJ was a volunteer Fire Fighter for the College Station FD.
- PJ's collegiate chorus performed the Chinese national anthem at the China-US Relations Conference in 2003
- PJ has lived in 9 places over the past 5 years.
Which one is not true? Leave a comment.


IDENTITY UNKNOWN
SEARCHING ASSETS
ADMIN:
FINCH, HAROLD
AUX_ADMIN:
INGRAM, NATHAN
PRIMARY ASSET:
REESE, JOHN


Wall is a medium level machine based on Linux, the initial approach is focused on enumeration and exploitation of a web application named Centreon.
Requires some basic/medium knowledge about HTTP requests and exploit customization.
The privilege escalation process is simple, based on the software named screen.
Recon
Starting with Nmap:
The scan result show us that the port 80 is open and accessing it results in the default Apache page:
Let’s enumerate using the gobuster tool:
The /monitoring directory returns a HTTP Basic Auth page, where we don’t have any credentials at moment.
Running the tool again with .php extension gave us some interesting .php files:
The aa.php file only returns “1”, doing some parameter fuzzing results in nothing.
The panel.php file returns “Just a test for php file !”, fuzzing the parameters results in nothing again.
Returning to monitoring and sending a POST request we got:
Then following the redirection we have the following response:
The /centreon page has a login form to the Centreon admin panel, version v.19.04.0:
Quick note about Centreon: Centreon is a web application that supervises hybrid infrastructures.
I made a small script to bruteforce the Centreon login form and after a couple tries we successfully got the credentials to the admin panel!
My bruteforce script:
Then we finally have access to the Centreon admin panel:
Exploiting - Understanding and modifying exploits
Searching for Centreon 19.04 exploits on Google we found an interesting exploit, it’s an authenticated RCE but this exploit doesn’t work for some reason.
Investigating the reason to why this exploit doesn’t work we found a command injection parameter inside the payload dictionary.
The nagios_bin parameter sends the reverse shell stager, this parameter can be found when you create or edit a Centreon pooler:
Sending this command through the parameter using the panel results in the following response from the server:
A WAF is behind the web application, blocking our requests that contains some illegal characters.
Trying to bypass this kind of protection we found a way to make it work, all we need to do is replace the whitespace with $IFS and encode part of the payload in base64:
After that we can bypass the WAF and update the Centreon pooler with our malicious parameter.
To trigger our exploit all we need to do is set up our netcat listener and send a POST request to the following endpoint:
After that we got a reverse shell as www-data user!
Exploiting - Using a custom exploit
For knowledge purposes I made a custom exploit that exploits this authentication RCE and spawn an interactive reverse shell to us, it’s available on my GitHub :)


The major pieces of the web are:
1. your browser - which displays files found on the web,
2. the Internet - the world's largest computer network,
3. HTTP - the main protocol of the web, and
4. servers - computers that host the files that make up the web.
HTML (hypertext markup language) is made up of:
+ text content (what you see)
+ mark up (what it looks like)
+ references to other documents (eg images & videos)
+ links to other pages
HTML mark up is a way to change how the content of the website looks.
An HTML element consists of opening tags and closing tags around contents
(like text). One example of mark up is making text bold, like the title above.
To do this, you type < b > text < /b > .
HTML elements can have attributes which provide additional information about the element. For example, the anchor tag is used for making links. If I want to include a link to the Udacity website by allowing you to click on the word Udacity in this sentence, I write < a href = "www.udacity.com" > Udacity < /a >.
 This means they can't think for themselves so programmers to write code to tell them what to do in the way they can understand. HTML is a language to tell the computer how to display the content in a website.


In which cases are the time complexities the same for Bubble Sort (as the algorithm is presented in this module)?
Does Bubble Sort's cost vary according to the order of the array input values?
No, it does not matter what order the input values have.


ANYTIME IS TRAIN TIME
Current Train Schedule
Train Name
Destination
Frequency(min)
Next Arrival
Minutes Away
Add Train
Train Name:
Destination:
First Train Time(HH:mm - military time):
Frequency (min):
Submit


From the list, select how the editor will be shown by default: both editor and preview panes, editor only, or preview only pane.


My name is TIGIRLAS GABRIEL. I am Self-motivated IT junior with good knowledge in JavaScript, HTML, CSS, and mobile responsive website development, with ability to learn fast and to write efficient code.
Web-Design
I create a unique design of sites and landings. Interface with usability, pure Flat and Material.
Lading
Effective selling websites. Unique design. Adaptive layout. SEO optimization.
Business Card Design
Creative Business cards for your company.
ZooMix COM
HTML, CSS, Javascript, PHP, MySql
The main goal is to provide you with the best range of pet products,low prices and high level of service.


Terms
Cufón is distributed under the MIT license. By using this tool you agree to its terms.
Should you require help you may ask for it at our Google Group, but keep
in mind that you are in no way entitled to support, which means that even if you do not
get a satisfactory answer you may not complain about it. Nice people are more likely to
get helpful answers.


View source on GitHub Send feedback
Copyright © 2020 Typedescriptor Privacy / Built using Hugo and Tailwind CSS


Understanding data about avocados
About the ProjectWe completed this project as a capstone project for DS 3001: Introduction to Data Science at WPI. We first selected the dataset we were using from Kaggle. Then, we cleaned the data and removed bad entries. For the analysis part of the project, we considered regions and filtered out individual cities to make the results less noisy. We hoped to understand avocado prices and consumption by region in the United States.
View the MapThis map buckets sizes the bubbles by total number of avocado bags purchased. They are broken up into 'buckets', and colored based on bucket. From this map, we can tell the Los Angeles and New York are the top consumers of avocados.
The size of an avocado does not indicate its ripeness or quality. Since the avocados seed grows with the fruit, the seed-to-fruit ratio will always be close to the same. Small avocados are the perfect size for on-the-go snacks, while larger avocados are best used for family sized portions.


About DLC
Our Worlds
Experiences
Gallery
Press
News
and Press
Latest New
News
Read Article
←
→
Press
Read Article
Read Article
Read Article
Read Article
←
→


CDO Data Request Page
I finally have this working!
Learn more here:
https://www.ncdc.noaa.gov/cdo-web/webservices/v2


{% extends 'base_profile_page.html' %} {% import 'macros.html' as macros %} {% block stylesheets %} {% endblock %} {% block head_misc %} {% endblock %} {% set nav_item = "profile" %} {% block page_title %} {{ profile_obj['name'] }} {% endblock %} {% block sidebar %}
If you could just take a moment to import your course history from your Quest transcript, you'll be able to rate and share courses you've taken with friends!
{% endif %} {# TODO(david): Make this backbone model view #} {% if show_import_schedule_button %}


--- title: Title keywords: fastai sidebar: home_sidebar summary: "summary" ---
initialize_non_glu
[source]
initialize_non_glu
(module
,input_dim
,output_dim
)
initialize_glu
[source]
initialize_glu
(module
,input_dim
,output_dim
)
class
GBN
[source]
GBN
(input_dim
,virtual_batch_size
=128
,momentum
=0.01
) ::Module
Ghost Batch Normalization https://arxiv.org/abs/1705.08741
class
AttentiveTransformer
[source]
AttentiveTransformer
(input_dim
,output_dim
,virtual_batch_size
=128
,momentum
=0.02
) ::Module
Base class for all neural network modules.
Your models should also subclass this class.
Modules can also contain other Modules, allowing to nest them in a tree structure. You can assign the submodules as regular attributes::
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__()
self.conv1 = nn.Conv2d(1, 20, 5)
self.conv2 = nn.Conv2d(20, 20, 5)
def forward(self, x):
x = F.relu(self.conv1(x))
return F.relu(self.conv2(x))
Submodules assigned in this way will be registered, and will have their
parameters converted too when you call :meth:to
, etc.
class
FeatTransformer
[source]
FeatTransformer
(input_dim
,output_dim
,shared_blocks
,n_glu
,virtual_batch_size
=128
,momentum
=0.02
) ::Module
Base class for all neural network modules.
Your models should also subclass this class.
Modules can also contain other Modules, allowing to nest them in a tree structure. You can assign the submodules as regular attributes::
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__()
self.conv1 = nn.Conv2d(1, 20, 5)
self.conv2 = nn.Conv2d(20, 20, 5)
def forward(self, x):
x = F.relu(self.conv1(x))
return F.relu(self.conv2(x))
Submodules assigned in this way will be registered, and will have their
parameters converted too when you call :meth:to
, etc.
class
GLU_Block
[source]
GLU_Block
(input_dim
,output_dim
,n_glu
=2
,first
=False
,virtual_batch_size
=128
,momentum
=0.02
) ::Module
Independant GLU block, specific to each step
class
GLU_Layer
[source]
GLU_Layer
(input_dim
,output_dim
,virtual_batch_size
=128
,momentum
=0.02
) ::Module
Base class for all neural network modules.
Your models should also subclass this class.
Modules can also contain other Modules, allowing to nest them in a tree structure. You can assign the submodules as regular attributes::
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__()
self.conv1 = nn.Conv2d(1, 20, 5)
self.conv2 = nn.Conv2d(20, 20, 5)
def forward(self, x):
x = F.relu(self.conv1(x))
return F.relu(self.conv2(x))
Submodules assigned in this way will be registered, and will have their
parameters converted too when you call :meth:to
, etc.


{{> head}}
{{> nav}}
Bulk delete
This is where you can bulk delete {{indexLower}}
TMS ids of {{indexLower}} to be deleted, one id per row.
{{missingIds}}
Delete
{{> tail}}


Interfaces that define which command line options and properties can be used.
The interface that is passed to the configuration manager is "ConfigurationUserParameters" which inherits from the other interfaces in this package.
For examples on which parameters exist and how to set them, see the database.defaults.properties file.


Turning This,
Salmon Cookies.
Welcome to Delicious
To This!
Look at this boring family eating their regular old milk and cookies. With Salmin cookies, you can just go ahead and dunk them into a pint of beer.
Turning This,
To This!
Look at this boring family eating their regular old milk and cookies. With Salmin cookies, you can just go ahead and dunk them into a pint of beer.


To upload a site, go
here.
read more


You have assigned the checklist to the Property(General Manager). Once he completes all the required details, the property will be submitted for review.
Checklist Status:
QC Status:
Info Needed
{{ partial "checklist-table.html" .}}
{{ partial "right-sidebar.html" .}}
Submit Property for Review
You're about to submit {{ .Params.property }} to the Goomo QC team for review.
Please make sure all the details you've entered are correct.


Sample Programs for Blockly RobotC for VexIQ
- Basic Movements
- Bumper Switch Sensor
- Control Structures
- Distance Sensor
- Functions
- Gyro Sensor
- LCD Display
- Multitasking
- Servos (Motors)
- Smart Motors and Encoders
- Sounds and Tones
- Wireless Controller (Remote Control)


Enter or copy/paste query protein sequences in FASTA format (Example):
{{ form.content }}
Upload input file in FASTA format (Example); {{ form.filename }}
6512 succinylation sites in the training set. downloaded positive samples .
6512 non-succinylation sites in the training set.downloaded negative samples.


---
,
---
Start
Reset
Randomize
Glider
Light-Weight
Spaceship
Middle-Weight
Spaceship
Heavy-Weight
Spaceship
Custom Pattern
Lock
Edit
Clone


These instructions assume you have a standard Tomcat installation running on port 8080. If you do not have an existing Tomcat installation, or want to start with a fresh installation for OpenEJB, the Tomcat Installation will show you how to setup and verify a Tomcat installation.
The TomEE plugin for Tomcat is distributed as a standalone war file containing all of the necessary files and an installer Servlet. The war can be obtained from the download page . Once downloaded, simply copy the file into the Tomcat webapps directory.
C:>dir apache-tomcat-6.0.14\webapps Volume in drive C has no label. Volume Serial Number is 0000-0000
Directory of C:\apache-tomcat-6.0.14\webapps
09/20/2007 03:03 PM
{card:label=Unix}{noformat:nopanel=true}
$ cp openejb.war apache-tomcat-6.0.14/webapps/openejb.war
$ ls apache-tomcat-6.0.14/webapps/
ROOT/ docs/ examples/ host-manager/ manager/
openejb.war
The OpenEJB Plugin for Tomcat contains an installer servlet which adds the OpenEJB listener and JavaAgent to the Tomcat installation. To run the installer, you must first start Tomcat.
C:>cd apache-tomcat-6.0.14\bin
C:\apache-tomcat-6.0.14\bin>startup.bat Using CATALINA_BASE: C:\apache-tomcat-6.0.14 Using CATALINA_HOME: C:\apache-tomcat-6.0.14 Using CATALINA_TMPDIR: C:\apache-tomcat-6.0.14\temp Using JRE_HOME: C:\your\java\installation
{card:label=Unix}{noformat:nopanel=true}
$ cd apache-tomcat-6.0.14/bin
apache-tomcat-6.0.14/bin$ chmod u+x *.sh
apache-tomcat-6.0.14/bin$ ./startup.sh
Using CATALINA_BASE: /your/tomcat/installation/apache-tomcat-6.0.14
Using CATALINA_HOME: /your/tomcat/installation/apache-tomcat-6.0.14
Using CATALINA_TMPDIR: /your/tomcat/installation/apache-tomcat-6.0.14/temp
Using JRE_HOME: /your/java/installation
NOTE: Your output will be different from the example above due to differences in installation locations.
It is a good idea to wait a 5-60 seconds (depending on the speed of your computer) for Tomcat to fully start. Once Tomcat is fully started, simply visit http://localhost:8080/openejb/installer and click the 'install' button to run the installer. The installer should report that the installation was successful. If it didn't work click [OPENEJB:here|#problems] .
OpenEJB uses OpenJPA for persistence and OpenJPA currently requires a JavaAgent to function. Unfortunately, there is no way to install a JavaAgent at runtime, so you will have to restart Tomcat to enable the JavaAgent. Simply execute the shutdown command, wait 5-60 seconds (depending on the speed of your computer) for Tomcat to fully stop, and run the startup command to restart Tomcat.
C:\apache-tomcat-6.0.14\bin>shutdown.bat Using CATALINA_BASE: C:\apache-tomcat-6.0.14 Using CATALINA_HOME: C:\apache-tomcat-6.0.14 Using CATALINA_TMPDIR: C:\apache-tomcat-6.0.14\temp Using JRE_HOME: C:\your\java\installation
C:\apache-tomcat-6.0.14\bin>startup.bat Using CATALINA_BASE: C:\apache-tomcat-6.0.14 Using CATALINA_HOME: C:\apache-tomcat-6.0.14 Using CATALINA_TMPDIR: C:\apache-tomcat-6.0.14\temp Using JRE_HOME: C:\your\java\installation
{card:label=Unix}{noformat:nopanel=true}
$ cd apache-tomcat-6.0.14/bin
apache-tomcat-6.0.14/bin$ ./shutdown.sh
Using CATALINA_BASE: /your/tomcat/installation/apache-tomcat-6.0.14
Using CATALINA_HOME: /your/tomcat/installation/apache-tomcat-6.0.14
Using CATALINA_TMPDIR: /your/tomcat/installation/apache-tomcat-6.0.14/temp
Using JRE_HOME: /your/java/installation
apache-tomcat-6.0.14/bin$ ./startup.sh
Using CATALINA_BASE: /your/tomcat/installation/apache-tomcat-6.0.14
Using CATALINA_HOME: /your/tomcat/installation/apache-tomcat-6.0.14
Using CATALINA_TMPDIR: /your/tomcat/installation/apache-tomcat-6.0.14/temp
Using JRE_HOME: /your/java/installation
NOTE: Your output will be different from the example above due to differences in installation locations.
Once Tomcat is fully started, simply visit http://localhost:8080/openejb/installer to verify the installation is complete.
Download the ejb-examples.war , copy it into the Tomcat webapps directory, and visit [http://localhost:8080/ejb-examples] .
OpenEJB uses a large test suite to verify the final server assembly, and you can use this to verify your OpenEJB installation. Simply download the openejb-itests.war and openejb-standalone-client.jar and copy it the war into the Tomcat webapps directory. It will take a bit to load the application because it contains a huge number of EJBs.  To specify a test suite configuration file by setting its location using the system property "openejb.testsuite.properties" test server = org.apache.openejb.test.TomcatRemoteTestServer entry = java.naming.provider.url:http://<IP_ADDRESS>:8080/openejb/ejb entry = java.naming.factory.initial:org.apache.openejb.client.RemoteInitialContextFactory ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ............................ Time: 20.644
OK (889 tests)
CLIENT JNDI PROPERTIES java.naming.provider.url = http://<IP_ADDRESS>:8080/openejb/ejb java.naming.factory.initial = org.apache.openejb.client.RemoteInitialContextFactory
{card:label=Unix}{noformat:nopanel=true}
$ java -jar openejb-itests-standalone-client.jar tomcat
_________________________________________________
|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
Running EJB compliance tests on HTTP/Tomcat Server
_________________________________________________
WARNING: No test suite configuration file specified, assuming system
properties contain all needed information. To specify a test suite configuration file by setting its location using the system property "openejb.testsuite.properties" test server = org.apache.openejb.test.TomcatRemoteTestServer entry = java.naming.provider.url:http://<IP_ADDRESS>:8080/openejb/ejb entry = java.naming.factory.initial:org.apache.openejb.client.RemoteInitialContextFactory ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ......................................... ............................ Time: 12.186
OK (889 tests)
_________________________________________________
CLIENT JNDI PROPERTIES
java.naming.provider.url = http://<IP_ADDRESS>:8080/openejb/ejb
java.naming.factory.initial =
org.apache.openejb.client.RemoteInitialContextFactory _____________________________________
Did you get a "HTTP Status 403" error page containing the description "Access to the specified resource () has been forbidden." when visiting http://localhost:8080/openejb ?
The openejb.war is protected by a Tomcat valve that restricts access to the application to the computer on which Tomcat is running. If your browser is running on the same computer as Tomcat, try accessing OpenEJB using this link instead http://<IP_ADDRESS>:8080/openejb .
If you want to access the openejb.war from another computer, you will need to either remove the valve, or modify the IP list in the valve declaration. The easiest way to remove the valve it to simply delete the webapps/openejb/META-INF/context.xml file and and the webapps/openejb.war file while Tomcat is stopped. The openejb.war file must be removed because some versions of Tomcat will use the context.xml file packed in the openejb.war file regardless of what is in the unpacked directory.
If you are having problems with the installation, please send a message to the OpenEJB users mailing list containing any error message(s) and the following information:
Tomcat 6.x - Currently, only Tomcat 6.x is supported due to API difference between 5.5.x and 6.x. It is expected that 5.5 will be supported in the future, but there are no plans to support 5.0.x due to the lack of annotation support in 5.0.x.
Security - Unfortunately, at this time security with Tomcat/OpenEJB is not integrated, but is being worked on.
EAR Files - The integration only supports war (and collapsed-ear) files. EAR, EJB Jar, and RAR files will be supported in a future release.
JavaAgent - OpenEJB uses OpenJPA to provide JPA and CMP persistence, and OpenJPA currently requires a JavaAgent to function properly. This requirement is something that the OpenJPA project is working on removing. Once removed, the OpenEJB plugin for Tomcat will no longer need to modify the startup shell scripts and you will not need to restart Tomcat after the OpenEJB installation.
This document is a starting point for using OpenEJB in Tomcat and will evolve based on user contributions. If you wish to contribute to this document, feel very welcome to click the 'Edit' link in the upper right and make changes and add new HOWTO's and other docs.


We can support your organisation’s rule of law and human rights projects and offer specialised, expert input into your work.
We can design and deliver training on all human rights and rule of law issues, in person and online. We can plan, coordinate and staff monitoring projects, draft and publish comprehensive independent reports on a state’s compliance with international standards and support your organisation’s advocacy work.
Through our membership and networks we can source lawyer and legal specialist volunteers with the relevant knowledge, experience and interest to assist in delivering programmes to support your organisation's initiatives. We are able to coordinate these volunteers, provide all necessary logistical support, and oversee the drafting of publications.
We are very happy to consider any proposals you may have for human rights or rule of law projects with which you would like our assistance.
Please email us for details and examples of our previous work and for references from our current and previous project partners. We do not currently publish information about previous projects online.
Observe is a group of lawyers and legal specialists dedicated to supporting and promoting rule of law and human rights projects worldwide.
The rule of law, in its most basic form, is the principle that no one is above the law.
It is the principle that everyone, from the individual to the state, is accountable to the law, and that there is a clear set of laws that are publicly stated and equally enforced. Critical to the protection of the rule of law is an independent judiciary that properly safeguards individuals from the arbitrary use of power by the state, organisations or other individuals.
Establishing respect for the rule of law is fundamental to the foundation of peaceful communities, the effective protection of human rights and to sustained economic development and progress.
A lack of the rule of law can be found in both democracies and dictatorships.
Our members have extensive knowledge of international, human rights and criminal law.
Our members have considerable experience of monitoring, and producing monitoring reports on trials, elections and demonstrations.
These reports have proved to be an important source of information for human rights NGOs in their advocacy work, and for policymakers, who are able to use the data to identify existing gaps in law, policy and practice.
Our members have provided training on human rights and rule of law issues to a variety of different audiences, including lawyers, activists, journalists, charities and others working in the field. We have also published documents on these issues.
We are always keen to expand our membership. We encourage applications from lawyers, legal academics, law students, or students in human rights studies, trainee lawyers and judges from all over the world.
Membership of Observe is free of charge and all our members are encouraged to get involved in our projects.
Rosa Curling is a UK and international human rights lawyer. She is at the forefront of claimant litigation, and has represented clients before the High Court, Court of Appeal, Supreme Court, European Court of Justice, European Court of Human Rights, International Criminal Court, as well as many domestic and international tribunals. Read more...
She has acted for clients in challenges to numerous UK national bodies, on a variety of different issues including public international law, international criminal law, health, education, corporate social responsibility, the environment, unlawful detention, freedom of information, the right to privacy, right to life, and the right to die. Some of her recent cases and press reports are listed below.
She is currently a trustee of Platform, a co-founder of Observe and a member of European Mediterranean Human Rights Network's Working Group on Freedom of Association and Assembly.
She has written and provided comment on a wide range of human rights issues in the national and international press as well as numerous conferences, seminars and other events. She recently wrote a chapter on the freedom of assembly and association in EMHRN's Regional Study on the freedom in the Euro-Mediterranean region.
She regularly provides training on human rights and public law issues both in the UK and elsewhere and currently provides five training sessions a year, in association with the Consultation Institute, on the law of consultation. She has undertaken both trial and demonstration monitoring missions in the UK and elsewhere.
She was previously been named the Times Lawyer of the Week and was shortlisted for Liberty Human Rights Lawyer of the Year 2014-2015.
Catherine Fischl is a UK based criminal lawyer working on a wide variety of criminal cases, the majority of which have an international element. Read more...
She acts for clients under investigation by the police and other UK prosecutors, and has represented clients being prosecuted in the UK Crown and Magistrates’ Courts and in cases litigated before the Court of Appeal, the High Court, the European General Court and the European Court of Justice. She regularly makes representations on behalf of her clients to a wide range of national and international government agencies including INTERPOL and the European Council.
As an extradition lawyer, Cath represents clients who are the subject of often politically motivated extradition requests made to the UK by foreign governments. Such cases involve careful review of the human rights position in the requesting country in relation to the right to life, the right to a fair trial and the right to liberty and security of the person.
Cath writes on criminal law related issues for various publications. She has acted as a trial monitor, has designed and presented training on the right to a fair trial and has experience of conducting workshops in relation to bribery and corruption issues in Europe, Russia and South-East Asia.
She is a co-founder of Observe and a member of the Association of Commonwealth Criminal Lawyers and the Young Fraud Lawyers Association.
Zoe Norden is a media law specialist currently working in-house for a global media organisation. Read more...
She has experience advising on a range of content-related matters including defamation, privacy, contempt of court, the official secrets act, PACE applications and reporting restrictions imposed in this jurisdiction and elsewhere. She also provides pre-publication advice and training to journalists carrying out multi-jurisdictional investigations. For example she has been involved in advising on matters arising out of Wikileaks coverage, the Leveson Inquiry, phone hacking reporting and on journalist investigations into undercover police officers.
She has represented clients before the High Court, Commercial Courts, Court of Appeal, Supreme Court and ECHR. Zoe also engages in challenging reporting restrictions imposed in other areas, such as Family and Coroners Courts. She was instrumental in the challenge by UK media organisations in what were described as unprecedented reporting restrictions imposed on journalists during a criminal trial relating to alleged terrorism related offences.
She also co-ordinates and oversees media challenges on open justice principles on behalf of the Media Lawyers Association and engages in government consultations in areas which impact the media. This includes playing an active role in challenging proposed changes to the law in particular in the areas of contempt and archives.
Zoe was a member of the Working Group formed by the Civil Justice to look at the issue of costs in defamation proceedings. She is a committee member of the Media Lawyers Association and member Media Law Resource Centre.
Jan Clements is a media law specialist and the current Senior Legal Adviser for Guardian News & Media Limited. She advises GNM on issues such as defamation, privacy, contempt of court, the official secrets act and reporting restrictions. She has conduct of GNMS’s post publication litigation. Read more...
Jan is an expert in public, human rights, freedom of information and data protection law, has led media challenges to secret trials and has lobbied government on the acquisition of communications data, police powers, access to courts and open justice.
She is a member of the Media Lawyers Association, Media Law Resource Centre and co-author of "Regulating journalism and newsgathering" in "Media Law and Practice" OUP. She has trained journalists, and has spoken at national and international conferences on all of these issues.
Jan is also actively engaged in human rights issues in southern Africa. She is currently on the National Executive Committee of Action for Southern Africa. She was a founding member of the Anti-Apartheid Women’s Committee and Secretary of the London Anti-Apartheid Committee that coordinated the activities of local London Anti-Apartheid groups.
In 1984 she organised, with Archbishop Trevor Huddleston, an interfaith colloquium on apartheid and later joined the staff of the International Defence and Aid Fund to support the families of political prisoners in South Africa, visiting Robben Island in the early 1990s to assess the needs of prisoners on their release.
Membership of Observe International is currently free of charge.
We encourage applications from lawyers, legal academics, law students, or students in human rights studies, trainee lawyers and judges from all over the world.
All opportunities to be involved in our work will be sent to our members.


About
<EMAIL_ADDRESS>Activity
CVE-2018-16370:PECSM-TEAM 2.2.2 has a file upload vulnerability
CVE-2018-16371:PECSM-TEAM 2.2.2 has multiple reflected Cross Site Scripting Vulnerability
CVE-2018-16372Ideacms has a reflected Cross Site Scripting Vulnerability
CVE-2018-16373:Frog CMS 0.9.5 has a file upload Vulnerability
CVE-2018-16374:Frog CMS 0.9.5 has a stored Cross Site Scripting Vulnerability


Girl Develop It is here to provide affordable and accessible programs to learn software through mentorship and hands-on instruction.
Some "rules"
Tell us about yourself.
How your computer accesses websites
But ALSO how computers talk to each other
JavaScript (in our context) is "client side"
You can run JavaScript on the server with the help of Node.js!
nvm install 8.9.4
node -v
in your terminal and see what it saysnpm install npm@latest -g
npm -v
in your terminal and see what it saysnode
to access the REPL, try out some JS! Use .exit
to exitnode [YOUR_FILE].js
cd
into itnpm init
npm init --yes
?Node.js contains many useful core modules for us to use, such one to use the file system
const fs = require('fs');
fs.readFile('ourfile.txt', 'utf8', function(err, data) {
// do things
});
const data = fs.readFileSync('ourfile.txt', 'utf8');
package.json
is a JSON file that defines information about your app, and npm knows about it
There are some rules around names and other parts of your package.json, and npm will warn you if it doesn't like something
node_modules
folderpackage.json
npm install express
npm install express
npm install express lodash ...
Tell npm to save a package to your package.json, or install multiple packages at once!
npm install
is smart!
npm install foo/foo
npm install ../foo
npm install<EMAIL_ADDRESS>npm install -g foo
A dependency is something your application needs to run (it depends on it!).
You might install a dependency that relies on something else, adding it to your dependency chain
.
Check out the dependency chain for express.
Some dependencies are only used in development mode (vs production), and these are known as devDependencies
in the package.json file.
npm install jest --save-dev
npm install jest -D
You can install packages as dev dependencies, meaning people who run the built package don't require these modules.
In the Node.js module system, each file is treated as a separate module.
A package describes a group of 1+ modules
var express = require('express');
npm install express
node_modules
folder, and run npm install
. npm installs your defined dependency!
app.js
file and require express
var express = require('express');
var app = express();
app.get('/', function (req, res) {
res.send('Welcome to the GDI Node Workshop!');
});
app.listen(3000, function () {
console.log('Your app is listening on port 3000!');
});
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1",
"start": "node server.js"
},
npm scripts allow you to use npm to manage a lot of your app using easy commands like npm start
, npm test
and more.
People use "scripts" in package.json to: compile or preprocess code, run tests, build for a deployment or environment, or really anything!
If you define an arbitrary key (not in npm docs), you can run it using npm run KEY
"scripts": {
...
"stuff": "echo \"LET'S DO STUFF\""
}
...
$ npm run stuff
app.js
to run a simple web server using ExpressThey're what you get back from a request 😎
"Routes" define how a server should respond to a certain request at a certain end point or path.
// app.<HTTP action>
app.get('/', function (req, res) {
res.send('Hello World!');
});
Exercise solutions at https://github.com/pselle/Intro-to-Node.js-Exercises