Time-interleaved SAR ADC generator¶
This section describes how to generate a time-interleaved SAR ADC schematic and layout using BAG and laygo.
Overview¶
Time Interleaved Successive Approximation ADC (TISARADC) is a popular way of implementing a moderate precision (4-10 bits) ADC that operates at higher sampling rates than single SAR ADCs can achieve. As an example of demonstrating the automated analog and mixed signal circuits generation flow, the entire TISARADC generator is explained here.
Installation¶
Set up a BAG/laygo working directory for the your technology. For example, cds_ff_mpt environment can be set up by running the following commands.
$ git clone git@github.com:ucb-art/BAG2_cds_ff_mpt.git $ cd BAG2_cds_ff_mpt $ git submodule init $ git submodule update $ git submodule foreach git pull origin master
Note: for BWRC users, comprehensive working environments are provided under proper NDAs for certain technologies. Use the following repos and skip step 2, 3, 5, 6.
- tsmc16FFC:
git@bwrcrepo.eecs.berkeley.edu:jdhan/TISARADC_TSMC16FFC.git
- tsmc28hpm:
- tsmc16FFC:
Copy configuration files and design libraries from laygo/generators/adc_sar/yaml by typing:
cp laygo/generators/adc_sar/yaml/adc_sar_spec.yaml . cp laygo/generators/adc_sar/yaml/adc_sar_size.yaml . cp -r laygo/generators/adc_sar/BagModules/adc_sar_templates BagModules/ cp -r laygo/generators/adc_sar/adc_sar_templates . cp -r laygo/generators/adc_sar/adc_sar_testbenches .
Note: some repos may already have those files in their working directories.
Add library definitions to your cds.lib (some distributions use cds.lib.core instead of cds.lib)
In cds.lib
DEFINE adc_sar_templates ./adc_sar_templates DEFINE adc_sar_testbenches ./adc_sar_testbenches
Open bag_lib.defs and remove the definition of adc_sar_templates if exist
In bag_lib.defs
adc_sar_templates BagModules #remove this
Run virtuoso and type the following command in CIW.
load "start_bag.il"
Open adc_sar_templates/capdac and update the library name of C0 and CDAC0 to **(technology_name)_micretemplates_dense**, as shown below.
Launch bag and run the following import script.
run laygo/generators/adc_sar/adc_sar_import.py
In the IPython interpreter, type the following command to construct the template and grid database. (Make sure proper techlib is attached to the microtemplate library)
run laygo/labs/lab2_a_gridlayoutgenerator_constructtemplate.py
Run the following command to generate the logic gate template library. The library name will be (technology_name)_logic_templates.
run laygo/generators/logic/logic_templates_layout_generator.py
Setting up parameters¶
ADC schematic and layout are constructed based on spec/size parameters defined in 2 configuration files in YAML format (adc_sar_spec.yaml, adc_sar_size.yaml).
Following parameters are defined in the configuration files:
- adc_sar_spec.yaml
- temp: nominal temperature
- temp_min: minimum temperature
- temp_max: maximum temperature
- v_in: nominal input swing (single ended)
- v_in_max: maximum input swing
- v_in_cm: nominal inpuut common mode
- n_bit: number of output bits
- n_bit_cal: number of output bits after digital calibration
- fsamp: effective sampling rate
- n_interleave: interleaving ratio
- c_unit: minimum unit capacitance of CDAC
- c_ground: grounded parasitic capacitance of c_unit
- c_delta: maximum capacitance mismatch of c_unit (normalized by c_unit)
- n_bit_samp_noise: standard deviation of sampling noise (in bits)
- n_bit_samp_settle: maximum sampler settling error in bits
- n_bit_comp_noise: standard deviation of comparator noise in bits
- rdx_array: CDAC radix array
- rdx_enob: Target ENOB after calibration
- cycle_comp: Comparator timing budget in cycle
- cycle_logic: Logic timing budget in cycle
- cycle_dac: DAC timing budget in cycle
- vdd: nominal supply voltage
- vdd_min: minimum supply voltage
- vdd_max: maximum supply voltage
- adc_sar_size.yaml
- capdac_c_m: multiplier of CDAC unit capacitor
- capdac_num_bits_vertical: CDAC number of bits in vertical direction
- capdac_num_bits_horizontal: CDAC number of bits in horizontal direction
- capdrv_m_list: cap driver multiplier list
- capdrv_space_offset: cap driver spacing parameter, for routing
- salatch_m: strongArm latch sizing
- salatch_m_buf: strongArm latch output buffer sizing
- salatch_m_rgnn: strongArm latch regenerative latch sizing
- salatch_m_rst: strongArm latch reset device sizing
- sarclkgen_m: strongArm latch clock generator sizing
- sarclkgen_fo: strongArm latch clock generator fanout
- sarclkgen_ndelay: strongArm latch clock generator # of delays
- sarret_m: strongArm latch output retimer sizing
- sarret_fo: strongArm latch output retimer fanout
- sarfsm_m: SAR FSM sizing
- sarlogic_m: SAR logic sizing
- dcap2_m:
- num_space_samp:
- num_space_sar:
For the starting point, following preset files are provided. They are not 100% finalized, but will serve well for initializations.
- **adc_sar_spec(size)_craft.yaml** : 9.6GS/s, 9bit ADC with digital calibration.
- **adc_sar_spec(size)_11b.yaml** : GS/s, 11bit ADC with digital calibration.
- **adc_sar_spec(size)_6b.yaml** : 2GS/s, 6bit ADC with radix-2 constellation.
TISARADC architecture¶
TISARADC is composed of 4 parts in the top level: ADC core, clock generator, output retimer and biasing.
- The ADC core performs the actual conversion operation. It is composed of multi-phased sampling frontend and N subADC that converts the actual ADC operation at (sampling_rate/N), where N is the interleaving ratio.
- The clock generator receives the high frequency clock at sampling rate, generates multi-phased clock for the interleaved ADC operation.
- The output retimer receives the output from the ADC core, aligns multi-phased signals to a single clock to be received by the following digital backend.
SubADC frontend layout generation¶
The frontend of subADCs is composed of three parts: capdac (CDAC), strongArm comparator (salatch), cap driver (capdrv). In the proposed flow, the ‘very’ frontend sampling switches are not the part of subADC frontend because they are designed separately, but obviously this is not the only way of partition.
The first block to be generated is CDAC, since this generator assumes the horizontal dimension is limited by CDAC size in x-direction. In order to generate CDAC layout, type:
run laygo/generators/adc_sar/adc_sar_capdac_layout_generator.py
This command will create a CDAC layout in adc_sar_generated/capdac, as shown below.
- The capdac generator reads n_bit and rdx_array parameters from adc_sar_spec.yaml, and capdac_c_m, capdac_num_bits_vertical, capdac_num_bits_horizontal parameters from adc_sar_size.yaml (or use default settings in the python code if load_from_file is set to false), users can update those parameters and regenerate the capdac. It will create a new CDAC with different shapes, as shown below.
If you want to generate the schematic as well, type:
run laygo/generators/adc_sar/adc_sar_capdac_schematic_generator.py
The figure shown below is one example of generated schematic. Note that CDAC capacitors (I0-I7) are arrayed, with radix parameters specified by rdx_array.
The schematic generation is not required for full-ADC generations, since you can generate the whole ADC schematic by running a top-cell generation script (unlike the layout counterpart, which requires running several scripts in series to generate the entire ADC). The CDAC schematic generation is used for cell level verifications though, such as LVS or transfer curve extraction. For LVS, type:
run laygo/generators/adc_sar/adc_sar_capdac_lvs.py
It will give a lvs passed message if the design is LVS clean.
Note: BAG2_cds_ff_mpt / FreePDK45 does not support LVS & extraction at this moment. Skip these steps for those processes
For parasitic extraction, type the following command.
run laygo/generators/adc_sar/adc_sar_capdac_extract.py
Note: this step could take a long time, depending on your extraction setup. Skip this if you just want to quickly go through steps.
You can run simulations on CDAC via BAG framework. The following command will launch the transfer curve simulation with schematic netlists. For the post-extract simulation, set extracted = True in the script.
run laygo/generators/adc_sar/adc_sar_capdac_verify.py
Simulation results from various settings (left: 5b-radix2, center: 8b-sub2radix, right: 10b-sub2radix)
After CDAC generation, strongArm latch layout can be generated by running:
run laygo/generators/adc_sar/adc_sar_salatch_pmos_layout_generator.py
- Here are additional scripts regarding the strongArm latch:
- adc_sar_salatch_pmos_schematic_generator.py: schematic generation
- adc_sar_salatch_pmos_schematic_lvs.py: LVS
- adc_sar_salatch_pmos_schematic_extract.py: RC extraction
- adc_sar_salatch_pmos_verify.py: verifications (clk-q, noise)
- Here are additional scripts regarding the strongArm latch:
The next step is generating capacitor drivers that drive CDAC. Run the following scripts:
run laygo/generators/adc_sar/adc_sar_capdrv_nsw_layout_generator.py run laygo/generators/adc_sar/adc_sar_capdrv_nsw_array_layout_generator.py
This is a 2-step generation; in the first script, individual driver cells are generated. The second script places driver cells (with the sizing parameters defined by capdrv_m_list in adc_sar_size.yaml.
Here’s one example layout of the capdrv.
Here’s the capdrv_array layout (primitive cells are hidden).
Now it’s time to generate the frontend top layout/schematic. Type:
run laygo/generators/adc_sar/adc_sar_sarafe_nsw_layout_generator.py run laygo/generators/adc_sar/adc_sar_sarafe_nsw_schematic_generator.py run laygo/generators/adc_sar/adc_sar_sarafe_nsw_lvs.py
The commands will create a layout (and schematic) of sarafe_nsw, which is the frontend top of subADC, and run LVS. Try different presets introduced before and see if designs are generated properly.
SubADC backend layout generation¶
The backend of subADCs is composed of FSM(sarfsm), SAR logic(sarlogic), clock generator(sarclkgen), and retimer(sarret).
Run following scripts to generate those building blocks.
 Again, BAG is generating schematics in hierarachical order, so you don’t need to run these scripts if you want to generate in top level.
#FSM layout run laygo/generators/adc_sar/adc_sar_sarfsm_schematic_generator.py #SAR logic run laygo/generators/adc_sar/adc_sar_sarlogic_wret_array_schematic_generator.py #SAR clock generator run laygo/generators/adc_sar/adc_sar_sarclkgen_static_schematic_generator.py #SAR retimer run laygo/generators/adc_sar/adc_sar_sarret_wckbuf_schematic_generator.py #spacing elements for routing/filling run laygo/generators/adc_sar/adc_sar_space_schematic_generator.py #SAR backend generation run laygo/generators/adc_sar/adc_sar_sarabe_dualdelay_schematic_generator.py
The frontend and backend can be integrated by running following scripts.
# layout run laygo/generators/adc_sar/adc_sar_sar_layout_generator.py # schematic run laygo/generators/adc_sar/adc_sar_sar_schematic_generator.py
SubADC switch generation¶
The sampling frontend can be generated either from laygo or AnalogBase. While the sampler generated from AnalogBase (written by Eric Chang) is more flexible, associated APIs need to be set up (which is not for the cds_ff_mpt technology), so laygo based sampler is used for this example.
Run the following script to generate the sampling switches.
# layout
run laygo/generators/adc_sar/adc_sar_sarsamp_layout_generator.py
# schematic
run laygo/generators/adc_sar/adc_sar_sarsamp_schematic_generator.py
If the AnalogBase is set up for your technology, these scripts will generate the sampling switches.
# layout
run laygo/generators/adc_sar/sampler_nmos_layout_generator.py
# schematic
run laygo/generators/adc_sar/sampler_nmos_schematic_generator.py
SubADC top generation¶
If all subblocks are generated sucessfully, the SubADC top (sar_wsamp) can be easily generated by placing and routing subcells. Run the following scripts to generate the SubADC top.
# layout
run laygo/generators/adc_sar/adc_sar_sar_wsamp_layout_generator.py
# schematic
run laygo/generators/adc_sar/adc_sar_sar_wsamp_schematic_generator.py
The generated layouts shown below are from the full-stack subADC generation with different settings (9b, 6b, 10bits and different sizing parameters).
Array generation¶
The SAR array can be easily made from running the following scripts.
# layout
run laygo/generators/adc_sar/adc_sar_sar_wsamp_array_layout_generator.py
# schematic
run laygo/generators/adc_sar/adc_sar_sar_wsamp_array_schematic_generator.py
Clocking path generation¶
Zhongkai Wang made schematic and layout generators for the clock generation. Running following scripts will generate the clocking frontend. (You don’t need this for non-interleaving ADCs)
run laygo/generators/adc_sar/clk_dis_capsw_array_layout_generator.py
run laygo/generators/adc_sar/clk_dis_clk_dis_cell_layout_generator.py
run laygo/generators/adc_sar/clk_dis_capdac_layout_generator.py
run laygo/generators/adc_sar/clk_dis_viadel_cell_layout_generator.py
run laygo/generators/adc_sar/clk_dis_viadel_layout_generator.py
run laygo/generators/adc_sar/clk_dis_htree_layout_generator.py
run laygo/generators/adc_sar/clk_dis_viadel_htree_layout_generator.py
run laygo/generators/adc_sar/clk_dis_viadel_htree_schematic_generator.py
The following picture shows generated clocking paths for different interleaving ratio settings
Retimer¶
(From now on, AnalogBase has to be set up for layout generations (which is not for the cds_ff_mpt technology)
Generator codes for the final retimer is written by Eric Chang. Run these scripts to generate the retimer schematic and layout.
run laygo/generators/adc_sar/adc_retimer_layout_generator.py
run laygo/generators/adc_sar/adc_retimer_schematic_generator.py
TISARADC body (clock+sar+retimer)¶
Following scripts are for generating layout and schematic of TISARADC body.
run laygo/generators/adc_sar/tisaradc_body_core_layout_generator.py
run laygo/generators/adc_sar/tisaradc_body_core_schematic_generator.py
Bias¶
Top¶
Full stack generation¶
in laygo/generators/adc_sar, there are various levels of full-stack generators (generating all up to the specified hierarchy). Their filenames end with fullstack_generator.py
Contributors¶
The generator codes are written by Jaeduk Han, Eric Chang, Zhongkai Wang, Woorham Bae, and Pengpeng Lu. This document is written by Jaeduk Han.


#include <graphics.h> void setwritemode(int mode);
COPY_PUT = 0 /* MOV */ XOR_PUT = 1 /* XOR */Each constant corresponds to a binary operation between each byte in the line and the corresponding bytes onscreen. COPY_PUT uses the assembly language MOV instruction, overwriting with the line whatever is on the screen. XOR_PUT uses the XOR command to combine the line with the screen. Two successive XOR commands will erase the line and restore the screen to its original appearance.
setwritemode currently works only with line, linerel, lineto, rectangle, and drawpoly.
/* setwritemode example */ #include <graphics.h> #include <stdlib.h> #include <stdio.h> #include <conio.h> int main() { /* request autodetection */ int gdriver = DETECT, gmode, errorcode; int xmax, ymax; /* initialize graphics and local variables */ initgraph(&gdriver, &gmode, ""); /* read result of initialization */ errorcode = graphresult(); if (errorcode != grOk) /* an error occurred */ { printf("Graphics error: %s\n", grapherrormsg(errorcode)); printf("Press any key to halt:"); getch(); exit(1); /* terminate with an error code */ } xmax = getmaxx(); ymax = getmaxy(); /* select XOR drawing mode */ setwritemode(XOR_PUT); /* draw a line */ line(0, 0, xmax, ymax); getch(); /* erase the line by drawing over it */ line(0, 0, xmax, ymax); getch(); /* select overwrite drawing mode */ setwritemode(COPY_PUT); /* draw a line */ line(0, 0, xmax, ymax); /* clean up */ getch(); closegraph(); return 0; }


Today, it's hard to imagine picking up a phone and messaging someone without embellishing the words - or replacing them entirely - with emoji. Emoji is so engrained in our culture that it's a shock to remember that until very recently, not all devices were even able to properly display them.
Today, emoji are so fundamental to communication that, as MONTAG's Kathryn Lawrence asks, can we now consider it a language on its own?
📖 No short history of emoji would be complete without mentioning its origin in Japan in the late 90s.
The word emoji shares only a coincidental similarity with “emotion” (which has its Latin root in “movement”); “emoji” comes from Japanese (e = picture, moji = character). The Unicode Consortium are the “shadowy overlords” of emoji, deciding which picture characters will be included in the universal language of Unicode, which allows for the translation of text characters across operating systems and displays.
And they are in charge of a particularly diverse and nuanced set of characters. The original set of 176 symbols has now expanded to include as many as 1,851 emojis, according to Emojipedia, including different flesh tones ordered by the Fitzpatrick scale.
The Emojipedia
There are too many clichés about language that one could apply to an analysis of the humble emoji: do they really speak louder than words, as numerous headlines have asserted? Is a 12 pixel by 12 pixel picture equal to a thousand words? What can an analysis of the usage of this pictorial “secret language” tell us about the state of online discourse?
Mark Davis, the president of the Unicode Consortium, says we shouldn't call it a language, and linguists classify text-based emoticons, such as colon-hyphen-close parenthesis or :-), and emoji, as “discourse particles” when they are used to convey tone.
💬 But the use of emoji as its own pictorial language similar to hieroglyphics is undeniable.
One of the most notable examples of emoji “translation” is Fred Benenson’s emoji adaptation of Moby Dick. In 2015, the Oxford Dictionary named “😂” (Laughing Crying, also known as Face With Tears Of Joy) its word of the year.
This emoji also happens to be the most popular, according to a 2017 study which ranked emoji use globally and found some interesting cultural differences in the results. As courtship increasingly takes place online over instant messages, another study has noted the emojis that elicit the most positive responses from men and women.
As an April Fools prank this year, Duolingo announced they would provide a course in emoji as a second language, but with new emoji coming out every year, it may actually be a necessary service for the unhip to be able to communicate. 2017’s new emojis to be released in Unicode 10 are already up on Emojipedia, but users who don’t have the latest operating systems will most likely see only empty squares.
👀 One of the arguments against counting emoji as a language is that they look different to everyone.
Face Screaming In Fear emoji via Mentalfloss
It’s up to the designers at Apple, Google, and other manufacturers to decide how they want their interpretation of the Unicode to display, which sometimes produces bizarre differences in the same emoji, which lead to differing interpretations of sentiment.
Hypebeast makes the case for emoji as the modern Rosetta stone, and its use in combination with those other internet-specific semiotic markers, memes, make a strong case for emoji as a universal language (although one writer has also argued that memes are a form of “semiotic anarchism.”
Let’s take the frog emoji as an example for semiotic analysis to see how its multiple meanings have been shaped by several divergent strands of online discourse.
Frog Face (🐸) is an icon, when used by amphibian enthusiasts: as a representation of an actual frog.
However, a lone Frog Face now carries a more insidious meaning in online discourse. Pepe the Frog, Matt Furie’s internet-famous cartoon character has been co-opted as a symbol of the American alt-right, a white nationalist group, and the Frog Face emoji now indexes as a reference to Pepe (as confirmed by Emojipedia).
The cartoon’s association with the political movement (and its subsequent pseudo-religious symbolism) has not only caused the cartoon character to be classified as a symbol of hate speech but also ruined a perfectly good animal emoji – if Frog Face is to be used innocuously, it must be accompanied by another discourse particle.
Frog Face followed by Hot Beverage (🐸☕) is used to refer to the meme known as “But That’s None Of My Business” symbolised by Kermit the Frog drinking tea:
Kermit drinking tea via Meme Generator
Although the citation is needed, Wikipedia’s entry for Kermit under “Frogs in Culture,” rings true:
“Kermit the Frog, on the other hand, is a conscientious and disciplined character of Sesame Street and The Muppet Show; while openly friendly and greatly talented, he is often portrayed as cringing at the fanciful behaviour of more flamboyant characters.”
Although the gist of the “But That’s None Of My Business” meme is that Kermit (and the user, as they identify themselves with the frog through use of the meme) is stirring up trouble with salacious gossip, they are also exhibiting self-restraint, and respecting social order. Whereas Pepe’s “feels good, man,” slogan, and whatever words of hate speech are put into the character’s mouth by the alt-right’s “meme armies”, defies social convention in favor of self-indulgence and shock value.
⚠ The cyber-ethno-herpetology of decoding frog symbols in internet culture clearly shows that frogs portray a spectrum that encompasses the full range of human emotions.

The 😁 same 😆 can ✨ be 🐝 said 💬 for 👌 emoji: 😂 they 🚫 don’t 🙅 only 👍 👍 allow us 👯 to 🌚 express 😝 emotion, they 💯 encompass the 👥 human 👤 experience, and ➕ as 🆘 they ♻ accrue cultural 🍑 meanings 🍆 through 😩 the 👏 out 👏 of 👏 control 👏 snowballing ❄ meaning-making 💦 process 🏭 that 😐 is 👾 internet 💻 culture and 👌 online 😘 discourse, they 😬 will 🔥 only 💥 become 😅 more 😱 complexly woven 🌐 into 👉 the 📜 fabric of 🆗 language and 🆒 society 🌍🌎🌏.


| Modifier and Type | Method and Description |
|---|---|
AndroidVersion |
getAndroidVersion()
Gets the version of Android installed on the device
represented by this object.
|
Battery |
getBattery()
Gets the device's battery.
|
BusyBox |
getBusyBox()
Gets an object referencing the
Device 's
busybox installation. |
static Device |
getDevice(Ip4Address inetAddress) |
static Device |
getDevice(Ip4Address inetAddress,
java.lang.String productString,
java.lang.String modelString,
DeviceState state) |
static Device |
getDevice(java.lang.String serialNo) |
static Device |
getDevice(java.lang.String serialNo,
java.lang.String productString,
java.lang.String modelString,
DeviceState state) |
DeviceState |
getDeviceState()
Gets the device's current state.
|
FileSystem |
getFileSystem()
Gets an instance of
FileSystem representing the file system on this device. |
java.lang.String |
getID()
Gets a device's identifier (ID)
|
Ip4Address |
getIpAddress()
Gets the device's IP address (and port).
|
java.lang.String |
getModelString()
Gets the device's model string.
|
java.lang.String |
getProductString()
Gets the device's product string.
|
double |
getSdkVersion()
Gets the SDK version installed on the device represented by
this object.
|
java.lang.String |
getSerialNumber()
Gets the device's serial number (as seen by ADB).
|
SuperUser |
getSuperUser()
|
AndroidVersion |
getVersion()
Gets the version of Android currently installed on the device.
|
boolean |
hasRoot()
Shortcut for determining whether a device is rooted or not.
|
boolean |
isConnectedViaTcpIp()
Gets a value indicating whether this device is connected to the host via
TCP/IP or not.
|
void |
rebootDevice()
Reboots this
Device to Android. |
void |
rebootDevice(RebootMode mode)
Reboots this
Device into a specified operating mode. |
public static Device getDevice(java.lang.String serialNo)
public static Device getDevice(java.lang.String serialNo, java.lang.String productString, java.lang.String modelString, DeviceState state)
public static Device getDevice(Ip4Address inetAddress)
public static Device getDevice(Ip4Address inetAddress, java.lang.String productString, java.lang.String modelString, DeviceState state)
public AndroidVersion getVersion()
AndroidVersion
public java.lang.String getSerialNumber()
null
if the device is connected via TCP/IP!public Ip4Address getIpAddress()
null
if the device is connected via TCP/IP!public boolean isConnectedViaTcpIp()
true
if the device is connected via TCP/IP. false
otherwise.public java.lang.String getProductString()
public java.lang.String getModelString()
public java.lang.String getID()
public DeviceState getDeviceState()
DeviceState
public AndroidVersion getAndroidVersion()
AndroidVersion
value.public double getSdkVersion()
public void rebootDevice(RebootMode mode) throws DeviceException
Device
into a specified operating mode.mode
- The mode to reboot to.DeviceException
- If an error occurs.RebootMode
public void rebootDevice() throws DeviceException
Device
to Android.DeviceException
- If an error occurs.public boolean hasRoot()
SuperUser.isInstalled()
true
if the Device
is rooted, false
otherwise.SuperUser
,
SuperUser.isInstalled()
public FileSystem getFileSystem()
FileSystem
representing the file system on this device.FileSystem
.FileSystem
public BusyBox getBusyBox()
Device
's
busybox installation.BusyBox


Europe Countries Factbook
What information do you want?
Total population
Birth rate
Death rate
Filter your information by:
Total population:
None
Less than
Greater than
thousands of people
Birth/Death rate:
birth rate
Not specified
Less than
Greater than
death rate
Language:


Early Life
Steve Jobs was born in San Francisco, 1955, to two university students Joanne Schieble and Syrian-born John Jandali. They were both unmarried at the time, and Steven was given up for adoption. Steven was adopted by Paul and Clara Jobs, whom he always considered to be his real parents. Steven’s father, Paul, encouraged him to experiment with electronics in their garage. This led to a lifelong interest in electronics and design. Jobs attended a local school in California and later enrolled at Reed College, Portland, Oregon. His education was characterised by excellent test results and potential. But, he struggled with formal education and his teachers reported he was a handful to teach. At Reed College, he attended a calligraphy course which fascinated him. He later said this course was instrumental in Apple’s multiple typefaces and proportionally spaced fonts.
Steve Jobs in India
In 1974, Jobs travelled with Daniel Kottke to India in search of spiritual enlightenment. They travelled to the Ashram of Neem Karoli Baba in Kainchi. During his several months in India, he became aware of Buddhist and Eastern spiritual philosophy. At this time, he also experimented with psychedelic drugs; he later commented that these counter-culture experiences were instrumental in giving him a wider perspective on life and business.
Job’s first real computer job came working for Atari computers. During his time at Atari, Jobs came to know Steve Wozniak well. Jobs greatly admired this computer technician, whom he had first met in 1971.
Steve Jobs and Apple
In 1976, Wozniak invented the first Apple I computer. Jobs, Wozniak and Ronald Wayne then set up Apple computers. In the very beginning, Apple computers were sold from Jobs parents’ garage.
Over the next few years, Apple computers expanded rapidly as the market for home computers began to become increasingly significant.
In 1984, Jobs designed the first Macintosh. It was the first commercially successful home computer to use a graphical user interface (based on Xerox Parc’s mouse driver interface.) This was an important milestone in home computing and the principle has become key in later home computers.
Despite the many innovative successes of Jobs at Apple, there was increased friction between Jobs and other workers at Apple. In 1985, removed from his managerial duties, Jobs resigned and left Apple. He later looked back on this incident and said that getting fired from Apple was one of the best things that happened to him – it helped him regain a sense of innovation and freedom, he couldn’t find work in a large company.
Life After Apple
On leaving Apple, Jobs founded NeXT computers. This was never particularly successful, failing to gain mass sales. However, in the 1990s, NeXT software was used as a framework in WebObjects used in Apple Store and iTunes store. In 1996, Apple bought NeXT for $429 million.
Much more successful was Job’s foray into Pixar – a computer graphic film production company. Disney contracted Pixar to create films such as Toy Story, A Bug’s Life and Finding Nemo. These animation movies were highly successful and profitable – giving Jobs respect and success.
In 1996, the purchase of NeXT brought Jobs back to Apple. He was given the post of chief executive. At the time, Apple had fallen way behind rivals such as Microsoft, and Apple was struggling to even make a profit.
Apple has been rated No.1 in America’s most admired companies. Jobs management has been described as inspirational, although c-workers also state, Jobs could be a hard taskmaster and was temperamental. NeXT Cofounder Dan’l Lewin was quoted in Fortune as saying of that period, “The highs were unbelievable … But the lows were unimaginable.”
Return to Apple
Jobs launched Apple in a new direction. With a certain degree of ruthlessness, some projects were summarily ended. Instead, Jobs promoted the development of a new wave of products which focused on accessibility, appealing design and innovate features.
The iPod was a revolutionary product in that it built on existing portable music devices and set the standard for portable digital music. In 2008, iTunes became the second biggest music retailer in the US, with over six billion song downloads and over 200 million iPods sold.
In 2007, Apple successfully entered the mobile phone market, with the iPhone. This used features of the iPod to offer a multi-functional and touchscreen device to become one of the best-selling electronic products. In 2010, he introduced the iPad – a revolutionary new style of tablet computers.
The design philosophy of Steve Jobs was to start with a fresh slate and imagine a new product that people would want to use. This contrasted with the alternative approach of trying to adapt current models to consumer feedback and focus groups. Job’s explains his philosophy of innovative design.


Please type some keys and see what happens. Notice that the event fired only once you pressed a key down and released it (only one event per keypress)


| Created: | 1/27/2021 3:53:39 PM |
| Modified: | 1/27/2021 3:53:39 PM |
| Project: | |
| Advanced: |
| Attribute |
|
Public serial id |
|
Details:
|
|
Public varchar(255) sub |
|
Details:
|
|
Public varchar(255) first_name |
|
Details:
|
|
Public varchar(255) last_name |
|
Details:
|
|
Public varchar(255) |
|
Details:
|
|
Public timestamp with time zone(0) created_at |
|
Details:
|
|
Public timestamp with time zone(0) updated_at |
|
Details:
|
|
Public varchar(255) created_by |
|
Details:
|
|
Public varchar(255) updated_by |
|
Details:
|
|
Public static varchar(255) oid |
|
Details:
|
|
Public varchar(255) phone |
|
Details:
|
|
Public varchar(255) title |
|
Details:
|
| Operation | ||
|
Public users_pkey( id: serial, |
||
|
Details:
<<PK>>
|
||
|
Public users_sub_unique( sub: varchar, |
||
|
Details:
<<unique>>
|
||
|
Public users_oid_unique( oid: varchar, |
||
|
Details:
<<unique>>
|
| Tag | Value |
| Owner | public |
|
Details:
|
| Property | Value |
| isFinalSpecialization: | 0 |


Last time we learned how to use stopwords with NLTK, today we are going to take a look at counting frequencies with NLTK.
You can find the project here.
To start we need some text to analyze. We could use some of the books which are integrated in NLTK, but I prefer to read from an external file. The best source of free ebooks to practice your text analysis skills is gutenberg. Project Gutenberg is an awesome "open source" project that offers more than 53.000 free ebooks. For this tutorial we are going to use Dracula by Bram Stoker, you can download it as a UTF-8 txt.
For this project we are going to create the folders like this:
You just need to download the utf-8 version of a book of your choice and save it as ebook.txt in data folder inside your project. You can download the stopwords from here.
Let's start coding!
import nltk
# Let's declare a function to get word index
def get_index(in_list,in_string):
for num,row in enumerate(in_list):
if in_string in row:
return num
# Let's open the book we downloaded
book = open('data/ebook.txt','r').read()
# Divide text by rows
rows = book.split('\n')
import nltk We import the necessary library as usual
get_index() We define a simple function which helps us find the index of a word inside of a list. We loop for every row and if we find the string we return the index of the string
open() and split() We load the book into a variable as a string and then we split it into lines
# Search for START and END tags to remove useless parts
start_idx = get_index(rows,' START')
end_idx = get_index(rows,' END')
rows = rows[start_idx+1:end_idx]
Now we look for START and END tags in our list and we redefine the list omitting the lines which are added by gutemberg.org.
# Create a list of words by converting to lowercase and splitting
words = [s.lower().split() for s in rows if s]
# Convert the list of lists into a flat list
words = [sublist for l in words for sublist in l]
# Import the stopwords
stop = open('data/stop.txt','r').read()
# Split the stopwords by line
stop = stop.split('\n')
# Remove punctuation and numbers from words
words = [''.join(c for c in w if c.isalpha()) for w in words]
# Remove stopwords and blanks from words
words = [w for w in words if w not in stop and w.isalpha()]
We create a list of words by following these steps:
• Convert all the rows to lowercase and split the row into words
• Flatten the list of lists into a single list of words
• Load the stopwords and split them by line
• Remove punctuation from words
• Remove stopwords and empty elements from words
text = nltk.Text(words)
# Calculate Frequency distribution
freq = nltk.FreqDist(text)
# Print and plot most common words
freq.most_common(20)
freq.plot(10)
Now we can load our words into NLTK and calculate the frequencies by using FreqDist(). After this we can use .most_common(20) to show in console 20 most common words or .plot(10) to show a line plot representing word frequencies:
Pretty boring words, how can we improve the output? We can use bigrams to show more relevant data. From Wikipedia: A bigram or digram is a sequence of two adjacent elements from a string of tokens, which are typically letters, syllables, or words.
# Get Bigrams from text
bigrams = nltk.bigrams(text)
# Calculate Frequency Distribution for Bigrams
freq_bi = nltk.FreqDist(bigrams)
# Print and plot most common bigrams
freq_bi.most_common(20)
freq_bi.plot(10)
After creating the bigrams we can plot them:
Pretty cool, right?
That's it for today. Have fun experimenting with word frequencies


Username This regular expression doesn’t validate username’s length
Dni (spanish ID card)
URL
CreditCard Validates Credit Card numbers, Checks if it contains 16 numbers in groups of 4 separated by -, space or nothing
MasterCard credit card
Visa credit card
US Social Security
General postal code Validates a 5 digits postal code
US ZIP code Validates US ZIP Code (basic and extended format)
Twitter username
Github username
Slideshare username
Del.icio.us username
RFC822 Email Address Regex
Originally written by Cal Henderson c.f. iamcal.com/publish/articles/php/parsing_email/
Translated to Ruby by Tim Fletcher, with changes suggested by Dan Kubb.
Licensed under a Creative Commons Attribution-ShareAlike 2.5 License creativecommons.org/licenses/by-sa/2.5/
Disabled; run with --debug to generate this.
Generated with the Darkfish Rdoc Generator 1.1.6.


{% extends 'base.html'%} {% block content %} {% for article in articles %}
... {{ article.publishedAt|truncate(13)}}
The home of BBC Sport online. Includes live sports coverage,...


module Main where
import Control.Monad.Eff.Console (log)
main = log "Hello, World!"
$ npm run repl
> import Prelude
$ psci
> :type 1.0
Number
> :type 1
Int
> :type true
Boolean
> :type "test"
String
> :type 'a'
Char
> :type [1, 2, 3]
Array Int
> :type [true, false]
Array Boolean
> :type [1, false]
Could not match type Int with Boolean.
myList :: Array Int
myList = [1, 2, 3, 4]
colors :: Array String
colors = ["red", "orange", "yellow", "green"]
user :: { name :: String, id :: Int }
user = {name: "Joe", id: 1}
Records correspond to JavaScript objects
add :: Int -> Int -> Int
add x y = x + y
add2 :: Int -> Int
add2 = add 2
-- These are all equivalent:
sum :: Int -> Int -> Int
sum x y = x + y
sum :: Int -> Int -> Int
sum x y = (+) x y
sum :: Int -> Int -> Int
sum x y = add x y
sum :: Int -> Int -> Int
sum x y = x `add` y
Operators are infix function calls
They all have a plain text alias e.g. + and add
"everything after goes in parentheses"
-- These are equivalent:
main = log $ "User: " <> "Foo"
main = log ("User: " <> "Foo")
-- These are equivalent:
main = log $ "User: " <> show $ 1 + 5
main = log ("User: " <> show (1 + 5))
(<> is for appending)
type Address =
{ street :: String
, city :: String
, state :: String
}
type AddressBook = Array Address
nums :: Array Int
nums = [4, 3, 22, 1, 7]
> :kind Array
Type -> Type
> :kind Array Int
Type
Array is a type constructor
Bower package: purescript-prelude
-- Most source files start like this:
module Foo where
import Prelude
-- Useful things like:
map :: forall a b. (a -> b) -> f a -> f b -- aka <$>
add :: forall a. Semiring a => a -> a -> a -- aka +
mul :: forall a. Semiring a => a -> a -> a -- aka *
eq :: forall a. Eq a => a -> a -> Boolean -- aka ==
notEq :: forall a. Eq a => a -> a -> Boolean -- aka /=
Prelude is your "standard library"
Bower package: purescript-arrays
insert :: forall a. Ord a => a -> Array a -> Array a
length :: forall a. Array a -> Int
filter :: forall a. (a -> Boolean) -> Array a -> Array a
union :: forall a. Eq a => Array a -> Array a -> Array a
zip :: forall a b. Array a -> Array b -> Array (Tuple a b)
gcd :: Int -> Int -> Int
gcd n 0 = n
gcd 0 m = m
gcd n m = if n > m
then gcd (n - m) m
else gcd n (m - n)
-- With guards:
gcd :: Int -> Int -> Int
gcd n 0 = n
gcd 0 n = n
gcd n m | n > m = gcd (n - m) m
| otherwise = gcd n (m - n)
isEmpty :: forall a. Array a -> Boolean
isEmpty [] = true
isEmpty _ = false
takeFive :: Array Int -> Int
takeFive [0, 1, a, b, _] = a * b
takeFive _ = 0
showPerson :: { first :: String, last :: String } -> String
showPerson { first: x, last: y } = y <> ", " <> x
showPerson :: { first :: String, last :: String } -> String
showPerson { first, last } = first <> ", " <> last
isEmpty :: forall a. Array a -> Boolean
isEmpty [] = true
isEmpty _ = false
-- Or equivalently:
isEmpty :: forall a. Array a -> Boolean
isEmpty arr = case arr of
[] -> true
_ -> false
-- v--type
data Filter = ByTitle | ByDate | ByRelevance
-- ^ data constructors
-- v-- function takes in type Filter
applyFilter :: forall a. Filter -> Array a -> Array a
applyFilter ByTitle =
applyFilter ByDate =
applyFilter ByRelevance =
-- ^ but you can pattern-match on the data constructor
data Shape
= Circle Point Number
| Rectangle Point Number Number
| Line Point Point
| Text Point String
draw :: Shape -> Drawing
draw (Circle pt radius) =
draw (Rectangle pt width height) =
draw (Line startPt endPt) =
draw (Text pt text) =
data Maybe a = Nothing | Just a
data Either a b = Left a | Right b
show :: Maybe User -> String
show (Just user) = user.firstName <> user.lastName
show Nothing = "No user!"
decodeJSON :: String -> Either ValidationErrors User
show :: Either ValidationErrors User -> String
show (Right user) = user.firstName <> user.lastName
show (Left errors) = "Errors: " <> show errors
For ADTs with one constructor that takes one type
At run time is same as underlying type
newtype PhoneNumber = PhoneNumber String
newtype UserId = UserId Int
-- Works the same as
data PhoneNumber = PhoneNumber String
data UserId = UserId Int
-- (except at run time)
Basically: like a Java interface
Tells what functions can be called on something
Then you can define functions that work with any value that has an instance for a type class
"What things can I do with this value"
Things that can be printed to a string
E.g. Booleans, Ints
class Show a where
show :: a -> String
-- E.g. Booleans can be printed to a string
instance showBoolean :: Show Boolean where
show true = "true"
show false = "false"
-- So you can define functions like this:
formatMsg :: forall a. (Show a) => a -> String
formatMsg val = "search-service: " <> show val
Things that can be tested for equality
E.g. Ints, Strings
class Eq a where
eq :: a -> a -> Boolean
instance eqInt :: Eq Int where
eq = refEq
instance eqString :: Eq String where
eq = refEq
> "foo" == "bar"
false
-- Floating points are hard
> 0.1 + 0.2 == 0.3
false
Things that can be sorted
E.g. strings, numbers
data Ordering = LT | EQ | GT
class Eq a <= Ord a where
compare :: a -> a -> Ordering
instance ordString :: Ord String where
compare = unsafeCompare
instance ordNumber :: Ord Number where
compare = unsafeCompare
> 2 > 3
false
> 2 `compare` 3
LT
> "b" > "a"
true
> "b" `compare` "a"
GT
Things that can be appended together
E.g. strings, arrays
class Semigroup a where
append :: a -> a -> a
infixr 5 append as <>
instance semigroupString :: Semigroup String where
append = concatString
instance semigroupArray :: Semigroup (Array a) where
append = concatArray
> "Hello " <> "World"
"Hello World"
> [1,2] <> [3,4]
[1,2,3,4]
Things that can be mapped over
E.g. arrays, optional values
class Functor f where
map :: forall a b. (a -> b) -> f a -> f b
> map ((+) 1) [1,2,3]
[2,3,4]
> map ((+) 1) (Just 2)
(Just 3)
> map ((+) 1) Nothing
Nothing
> map ((+) 1) (Right 2 :: Either String Int)
(Right 3)
> map ((+) 1) (Left "error" :: Either String Int)
(Left "error")
Things that can be encoded to/decoded from JSON
-- Take a value, encode to JSON
class Encode a where
encode :: a -> Foreign
-- Decode JSON, get a value or errors
class Decode a where
decode :: Foreign -> Except MultipleErrors a
Type classes define ways of piping and transforming data:
import Data.Generic.Rep as G
import Data.Generic.Rep.Eq as GEq
import Data.Generic.Rep.Ord as GOrd
import Data.Generic.Rep.Show as GShow
data Foo = A | B | C | D
derive instance genericFoo :: G.Generic Foo _
instance eqFoo :: Eq Foo where
eq x y = GEq.genericEq x y
instance ordFoo :: Ord Foo where
compare x y = GOrd.genericCompare x y
instance showFoo :: Show Foo where
show x = GShow.genericShow x
You don't always have to write type class instances by hand
Wrap it in newtype, then write the instance for the newtype
import Data.Generic.Rep as G
import Data.Generic.Rep.Eq as GEq
import Data.Generic.Rep.Ord as GOrd
import Data.Generic.Rep.Show as GShow
-- type FooRecord = { a :: String, b :: String }
-- ->
newtype FooRecord = FooRecord { a :: String, b :: String }
derive instance genericFooRecord :: G.Generic FooRecord _
instance eqFooRecord :: Eq FooRecord where
eq x y = GEq.genericEq x y
instance ordFooRecord :: Ord FooRecord where
compare x y = GOrd.genericCompare x y
instance showFooRecord :: Show FooRecord where
show x = GShow.genericShow x


(Appears in: KubeletConfiguration)
LoggingConfiguration contains logging options Refer [Logs Options](https://github.com/kubernetes/component-base/blob/master/logs/options.go) for more information.
| Field | Description |
|---|---|
format
*
string
|
Format Flag specifies the structure of log messages. default value of format is `text` |
sanitization
*
bool
|
[Experimental] When enabled prevents logging of fields tagged as sensitive (passwords, keys, tokens). Runtime log sanitization may introduce significant computation overhead and therefore should not be enabled in production.`) |
KubeletConfiguration contains the configuration for the Kubelet
| Field | Description |
|---|---|
apiVersion string |
kubelet.config.k8s.io/v1beta1 |
kind string |
KubeletConfiguration |
enableServer
*
bool
|
enableServer enables Kubelet's secured server. Note: Kubelet's insecure port is controlled by the readOnlyPort option. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may disrupt components that interact with the Kubelet server. Default: true |
staticPodPath
string
|
staticPodPath is the path to the directory containing local (static) pods to run, or the path to a single static pod file. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that the set of static pods specified at the new path may be different than the ones the Kubelet initially started with, and this may disrupt your node. Default: "" |
syncFrequency
meta/v1.Duration
|
syncFrequency is the max period between synchronizing running containers and config. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that shortening this duration may have a negative performance impact, especially as the number of Pods on the node increases. Alternatively, increasing this duration will result in longer refresh times for ConfigMaps and Secrets. Default: "1m" |
fileCheckFrequency
meta/v1.Duration
|
fileCheckFrequency is the duration between checking config files for new data Dynamic Kubelet Config (beta): If dynamically updating this field, consider that shortening the duration will cause the Kubelet to reload local Static Pod configurations more frequently, which may have a negative performance impact. Default: "20s" |
httpCheckFrequency
meta/v1.Duration
|
httpCheckFrequency is the duration between checking http for new data Dynamic Kubelet Config (beta): If dynamically updating this field, consider that shortening the duration will cause the Kubelet to poll staticPodURL more frequently, which may have a negative performance impact. Default: "20s" |
staticPodURL
string
|
staticPodURL is the URL for accessing static pods to run Dynamic Kubelet Config (beta): If dynamically updating this field, consider that the set of static pods specified at the new URL may be different than the ones the Kubelet initially started with, and this may disrupt your node. Default: "" |
staticPodURLHeader
map[string][]string
|
staticPodURLHeader is a map of slices with HTTP headers to use when accessing the podURL Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may disrupt the ability to read the latest set of static pods from StaticPodURL. Default: nil |
address
string
|
address is the IP address for the Kubelet to serve on (set to <IP_ADDRESS> for all interfaces). Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may disrupt components that interact with the Kubelet server. Default: "<IP_ADDRESS>" |
port
int32
|
port is the port for the Kubelet to serve on. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may disrupt components that interact with the Kubelet server. Default: 10250 |
readOnlyPort
int32
|
readOnlyPort is the read-only port for the Kubelet to serve on with no authentication/authorization. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may disrupt components that interact with the Kubelet server. Default: 0 (disabled) |
tlsCertFile
string
|
tlsCertFile is the file containing x509 Certificate for HTTPS. (CA cert, if any, concatenated after server cert). If tlsCertFile and tlsPrivateKeyFile are not provided, a self-signed certificate and key are generated for the public address and saved to the directory passed to the Kubelet's --cert-dir flag. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may disrupt components that interact with the Kubelet server. Default: "" |
tlsPrivateKeyFile
string
|
tlsPrivateKeyFile is the file containing x509 private key matching tlsCertFile Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may disrupt components that interact with the Kubelet server. Default: "" |
tlsCipherSuites
[]string
|
TLSCipherSuites is the list of allowed cipher suites for the server. Values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may disrupt components that interact with the Kubelet server. Default: nil |
tlsMinVersion
string
|
TLSMinVersion is the minimum TLS version supported. Values are from tls package constants (https://golang.org/pkg/crypto/tls/#pkg-constants). Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may disrupt components that interact with the Kubelet server. Default: "" |
rotateCertificates
bool
|
rotateCertificates enables client certificate rotation. The Kubelet will request a new certificate from the certificates.k8s.io API. This requires an approver to approve the certificate signing requests. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that disabling it may disrupt the Kubelet's ability to authenticate with the API server after the current certificate expires. Default: false |
serverTLSBootstrap
bool
|
serverTLSBootstrap enables server certificate bootstrap. Instead of self signing a serving certificate, the Kubelet will request a certificate from the certificates.k8s.io API. This requires an approver to approve the certificate signing requests. The RotateKubeletServerCertificate feature must be enabled. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that disabling it will stop the renewal of Kubelet server certificates, which can disrupt components that interact with the Kubelet server in the long term, due to certificate expiration. Default: false |
authentication
KubeletAuthentication
|
authentication specifies how requests to the Kubelet's server are authenticated Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may disrupt components that interact with the Kubelet server. Defaults: anonymous: enabled: false webhook: enabled: true cacheTTL: "2m" |
authorization
KubeletAuthorization
|
authorization specifies how requests to the Kubelet's server are authorized Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may disrupt components that interact with the Kubelet server. Defaults: mode: Webhook webhook: cacheAuthorizedTTL: "5m" cacheUnauthorizedTTL: "30s" |
registryPullQPS
int32
|
registryPullQPS is the limit of registry pulls per second. Set to 0 for no limit. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may impact scalability by changing the amount of traffic produced by image pulls. Default: 5 |
registryBurst
int32
|
registryBurst is the maximum size of bursty pulls, temporarily allows pulls to burst to this number, while still not exceeding registryPullQPS. Only used if registryPullQPS > 0. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may impact scalability by changing the amount of traffic produced by image pulls. Default: 10 |
eventRecordQPS
int32
|
eventRecordQPS is the maximum event creations per second. If 0, there is no limit enforced. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may impact scalability by changing the amount of traffic produced by event creations. Default: 5 |
eventBurst
int32
|
eventBurst is the maximum size of a burst of event creations, temporarily allows event creations to burst to this number, while still not exceeding eventRecordQPS. Only used if eventRecordQPS > 0. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may impact scalability by changing the amount of traffic produced by event creations. Default: 10 |
enableDebuggingHandlers
bool
|
enableDebuggingHandlers enables server endpoints for log access and local running of containers and commands, including the exec, attach, logs, and portforward features. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that disabling it may disrupt components that interact with the Kubelet server. Default: true |
enableContentionProfiling
bool
|
enableContentionProfiling enables lock contention profiling, if enableDebuggingHandlers is true. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that enabling it may carry a performance impact. Default: false |
healthzPort
int32
|
healthzPort is the port of the localhost healthz endpoint (set to 0 to disable) Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may disrupt components that monitor Kubelet health. Default: 10248 |
healthzBindAddress
string
|
healthzBindAddress is the IP address for the healthz server to serve on Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may disrupt components that monitor Kubelet health. Default: "<IP_ADDRESS>" |
oomScoreAdj
int32
|
oomScoreAdj is The oom-score-adj value for kubelet process. Values must be within the range [-1000, 1000]. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may impact the stability of nodes under memory pressure. Default: -999 |
clusterDomain
string
|
clusterDomain is the DNS domain for this cluster. If set, kubelet will configure all containers to search this domain in addition to the host's search domains. Dynamic Kubelet Config (beta): Dynamically updating this field is not recommended, as it should be kept in sync with the rest of the cluster. Default: "" |
clusterDNS
[]string
|
clusterDNS is a list of IP addresses for the cluster DNS server. If set, kubelet will configure all containers to use this for DNS resolution instead of the host's DNS servers. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that changes will only take effect on Pods created after the update. Draining the node is recommended before changing this field. Default: nil |
streamingConnectionIdleTimeout
meta/v1.Duration
|
streamingConnectionIdleTimeout is the maximum time a streaming connection can be idle before the connection is automatically closed. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may impact components that rely on infrequent updates over streaming connections to the Kubelet server. Default: "4h" |
nodeStatusUpdateFrequency
meta/v1.Duration
|
nodeStatusUpdateFrequency is the frequency that kubelet computes node status. If node lease feature is not enabled, it is also the frequency that kubelet posts node status to master. Note: When node lease feature is not enabled, be cautious when changing the constant, it must work with nodeMonitorGracePeriod in nodecontroller. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may impact node scalability, and also that the node controller's nodeMonitorGracePeriod must be set to N∗NodeStatusUpdateFrequency, where N is the number of retries before the node controller marks the node unhealthy. Default: "10s" |
nodeStatusReportFrequency
meta/v1.Duration
|
nodeStatusReportFrequency is the frequency that kubelet posts node status to master if node status does not change. Kubelet will ignore this frequency and post node status immediately if any change is detected. It is only used when node lease feature is enabled. nodeStatusReportFrequency's default value is 1m. But if nodeStatusUpdateFrequency is set explicitly, nodeStatusReportFrequency's default value will be set to nodeStatusUpdateFrequency for backward compatibility. Default: "1m" |
nodeLeaseDurationSeconds
int32
|
nodeLeaseDurationSeconds is the duration the Kubelet will set on its corresponding Lease, when the NodeLease feature is enabled. This feature provides an indicator of node health by having the Kubelet create and periodically renew a lease, named after the node, in the kube-node-lease namespace. If the lease expires, the node can be considered unhealthy. The lease is currently renewed every 10s, per KEP-0009. In the future, the lease renewal interval may be set based on the lease duration. Requires the NodeLease feature gate to be enabled. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that decreasing the duration may reduce tolerance for issues that temporarily prevent the Kubelet from renewing the lease (e.g. a short-lived network issue). Default: 40 |
imageMinimumGCAge
meta/v1.Duration
|
imageMinimumGCAge is the minimum age for an unused image before it is garbage collected. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may trigger or delay garbage collection, and may change the image overhead on the node. Default: "2m" |
imageGCHighThresholdPercent
int32
|
imageGCHighThresholdPercent is the percent of disk usage after which image garbage collection is always run. The percent is calculated as this field value out of 100. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may trigger or delay garbage collection, and may change the image overhead on the node. Default: 85 |
imageGCLowThresholdPercent
int32
|
imageGCLowThresholdPercent is the percent of disk usage before which image garbage collection is never run. Lowest disk usage to garbage collect to. The percent is calculated as this field value out of 100. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may trigger or delay garbage collection, and may change the image overhead on the node. Default: 80 |
volumeStatsAggPeriod
meta/v1.Duration
|
How frequently to calculate and cache volume disk usage for all pods Dynamic Kubelet Config (beta): If dynamically updating this field, consider that shortening the period may carry a performance impact. Default: "1m" |
kubeletCgroups
string
|
kubeletCgroups is the absolute name of cgroups to isolate the kubelet in Dynamic Kubelet Config (beta): This field should not be updated without a full node reboot. It is safest to keep this value the same as the local config. Default: "" |
systemCgroups
string
|
systemCgroups is absolute name of cgroups in which to place all non-kernel processes that are not already in a container. Empty for no container. Rolling back the flag requires a reboot. Dynamic Kubelet Config (beta): This field should not be updated without a full node reboot. It is safest to keep this value the same as the local config. Default: "" |
cgroupRoot
string
|
cgroupRoot is the root cgroup to use for pods. This is handled by the container runtime on a best effort basis. Dynamic Kubelet Config (beta): This field should not be updated without a full node reboot. It is safest to keep this value the same as the local config. Default: "" |
cgroupsPerQOS
bool
|
Enable QoS based Cgroup hierarchy: top level cgroups for QoS Classes And all Burstable and BestEffort pods are brought up under their specific top level QoS cgroup. Dynamic Kubelet Config (beta): This field should not be updated without a full node reboot. It is safest to keep this value the same as the local config. Default: true |
cgroupDriver
string
|
driver that the kubelet uses to manipulate cgroups on the host (cgroupfs or systemd) Dynamic Kubelet Config (beta): This field should not be updated without a full node reboot. It is safest to keep this value the same as the local config. Default: "cgroupfs" |
cpuManagerPolicy
string
|
CPUManagerPolicy is the name of the policy to use. Requires the CPUManager feature gate to be enabled. Dynamic Kubelet Config (beta): This field should not be updated without a full node reboot. It is safest to keep this value the same as the local config. Default: "none" |
cpuManagerReconcilePeriod
meta/v1.Duration
|
CPU Manager reconciliation period. Requires the CPUManager feature gate to be enabled. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that shortening the period may carry a performance impact. Default: "10s" |
topologyManagerPolicy
string
|
TopologyManagerPolicy is the name of the policy to use. Policies other than "none" require the TopologyManager feature gate to be enabled. Dynamic Kubelet Config (beta): This field should not be updated without a full node reboot. It is safest to keep this value the same as the local config. Default: "none" |
topologyManagerScope
string
|
TopologyManagerScope represents the scope of topology hint generation that topology manager requests and hint providers generate. "pod" scope requires the TopologyManager feature gate to be enabled. Default: "container" |
qosReserved
map[string]string
|
qosReserved is a set of resource name to percentage pairs that specify the minimum percentage of a resource reserved for exclusive use by the guaranteed QoS tier. Currently supported resources: "memory" Requires the QOSReserved feature gate to be enabled. Dynamic Kubelet Config (beta): This field should not be updated without a full node reboot. It is safest to keep this value the same as the local config. Default: nil |
runtimeRequestTimeout
meta/v1.Duration
|
runtimeRequestTimeout is the timeout for all runtime requests except long running requests - pull, logs, exec and attach. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may disrupt components that interact with the Kubelet server. Default: "2m" |
hairpinMode
string
|
hairpinMode specifies how the Kubelet should configure the container bridge for hairpin packets. Setting this flag allows endpoints in a Service to loadbalance back to themselves if they should try to access their own Service. Values: "promiscuous-bridge": make the container bridge promiscuous. "hairpin-veth": set the hairpin flag on container veth interfaces. "none": do nothing. Generally, one must set --hairpin-mode=hairpin-veth to achieve hairpin NAT, because promiscuous-bridge assumes the existence of a container bridge named cbr0. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may require a node reboot, depending on the network plugin. Default: "promiscuous-bridge" |
maxPods
int32
|
maxPods is the number of pods that can run on this Kubelet. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that changes may cause Pods to fail admission on Kubelet restart, and may change the value reported in Node.Status.Capacity[v1.ResourcePods], thus affecting future scheduling decisions. Increasing this value may also decrease performance, as more Pods can be packed into a single node. Default: 110 |
podCIDR
string
|
The CIDR to use for pod IP addresses, only used in standalone mode. In cluster mode, this is obtained from the master. Dynamic Kubelet Config (beta): This field should always be set to the empty default. It should only set for standalone Kubelets, which cannot use Dynamic Kubelet Config. Default: "" |
podPidsLimit
int64
|
PodPidsLimit is the maximum number of pids in any pod. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that lowering it may prevent container processes from forking after the change. Default: -1 |
resolvConf
string
|
ResolverConfig is the resolver configuration file used as the basis for the container DNS resolution configuration. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that changes will only take effect on Pods created after the update. Draining the node is recommended before changing this field. Default: "/etc/resolv.conf" |
runOnce
bool
|
RunOnce causes the Kubelet to check the API server once for pods, run those in addition to the pods specified by static pod files, and exit. Default: false |
cpuCFSQuota
bool
|
cpuCFSQuota enables CPU CFS quota enforcement for containers that specify CPU limits. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that disabling it may reduce node stability. Default: true |
cpuCFSQuotaPeriod
meta/v1.Duration
|
CPUCFSQuotaPeriod is the CPU CFS quota period value, cpu.cfs_period_us. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that limits set for containers will result in different cpu.cfs_quota settings. This will trigger container restarts on the node being reconfigured. Default: "100ms" |
nodeStatusMaxImages
int32
|
nodeStatusMaxImages caps the number of images reported in Node.Status.Images. Note: If -1 is specified, no cap will be applied. If 0 is specified, no image is returned. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that different values can be reported on node status. Default: 50 |
maxOpenFiles
int64
|
maxOpenFiles is Number of files that can be opened by Kubelet process. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may impact the ability of the Kubelet to interact with the node's filesystem. Default: 1000000 |
contentType
string
|
contentType is contentType of requests sent to apiserver. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may impact the ability for the Kubelet to communicate with the API server. If the Kubelet loses contact with the API server due to a change to this field, the change cannot be reverted via dynamic Kubelet config. Default: "application/vnd.kubernetes.protobuf" |
kubeAPIQPS
int32
|
kubeAPIQPS is the QPS to use while talking with kubernetes apiserver Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may impact scalability by changing the amount of traffic the Kubelet sends to the API server. Default: 5 |
kubeAPIBurst
int32
|
kubeAPIBurst is the burst to allow while talking with kubernetes apiserver Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may impact scalability by changing the amount of traffic the Kubelet sends to the API server. Default: 10 |
serializeImagePulls
bool
|
serializeImagePulls when enabled, tells the Kubelet to pull images one at a time. We recommend ∗not∗ changing the default value on nodes that run docker daemon with version < 1.9 or an Aufs storage backend. Issue #10959 has more details. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may impact the performance of image pulls. Default: true |
evictionHard
map[string]string
|
Map of signal names to quantities that defines hard eviction thresholds. For example: {"memory.available": "300Mi"}. To explicitly disable, pass a 0% or 100% threshold on an arbitrary resource. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may trigger or delay Pod evictions. Default: memory.available: "100Mi" nodefs.available: "10%" nodefs.inodesFree: "5%" imagefs.available: "15%" |
evictionSoft
map[string]string
|
Map of signal names to quantities that defines soft eviction thresholds. For example: {"memory.available": "300Mi"}. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may trigger or delay Pod evictions, and may change the allocatable reported by the node. Default: nil |
evictionSoftGracePeriod
map[string]string
|
Map of signal names to quantities that defines grace periods for each soft eviction signal. For example: {"memory.available": "30s"}. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may trigger or delay Pod evictions. Default: nil |
evictionPressureTransitionPeriod
meta/v1.Duration
|
Duration for which the kubelet has to wait before transitioning out of an eviction pressure condition. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that lowering it may decrease the stability of the node when the node is overcommitted. Default: "5m" |
evictionMaxPodGracePeriod
int32
|
Maximum allowed grace period (in seconds) to use when terminating pods in response to a soft eviction threshold being met. This value effectively caps the Pod's TerminationGracePeriodSeconds value during soft evictions. Note: Due to issue #64530, the behavior has a bug where this value currently just overrides the grace period during soft eviction, which can increase the grace period from what is set on the Pod. This bug will be fixed in a future release. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that lowering it decreases the amount of time Pods will have to gracefully clean up before being killed during a soft eviction. Default: 0 |
evictionMinimumReclaim
map[string]string
|
Map of signal names to quantities that defines minimum reclaims, which describe the minimum amount of a given resource the kubelet will reclaim when performing a pod eviction while that resource is under pressure. For example: {"imagefs.available": "2Gi"} Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may change how well eviction can manage resource pressure. Default: nil |
podsPerCore
int32
|
podsPerCore is the maximum number of pods per core. Cannot exceed MaxPods. If 0, this field is ignored. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that changes may cause Pods to fail admission on Kubelet restart, and may change the value reported in Node.Status.Capacity[v1.ResourcePods], thus affecting future scheduling decisions. Increasing this value may also decrease performance, as more Pods can be packed into a single node. Default: 0 |
enableControllerAttachDetach
bool
|
enableControllerAttachDetach enables the Attach/Detach controller to manage attachment/detachment of volumes scheduled to this node, and disables kubelet from executing any attach/detach operations Dynamic Kubelet Config (beta): If dynamically updating this field, consider that changing which component is responsible for volume management on a live node may result in volumes refusing to detach if the node is not drained prior to the update, and if Pods are scheduled to the node before the volumes.kubernetes.io/controller-managed-attach-detach annotation is updated by the Kubelet. In general, it is safest to leave this value set the same as local config. Default: true |
protectKernelDefaults
bool
|
protectKernelDefaults, if true, causes the Kubelet to error if kernel flags are not as it expects. Otherwise the Kubelet will attempt to modify kernel flags to match its expectation. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that enabling it may cause the Kubelet to crash-loop if the Kernel is not configured as Kubelet expects. Default: false |
makeIPTablesUtilChains
bool
|
If true, Kubelet ensures a set of iptables rules are present on host. These rules will serve as utility rules for various components, e.g. KubeProxy. The rules will be created based on IPTablesMasqueradeBit and IPTablesDropBit. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that disabling it will prevent the Kubelet from healing locally misconfigured iptables rules. Default: true |
iptablesMasqueradeBit
int32
|
iptablesMasqueradeBit is the bit of the iptables fwmark space to mark for SNAT Values must be within the range [0, 31]. Must be different from other mark bits. Warning: Please match the value of the corresponding parameter in kube-proxy. TODO: clean up IPTablesMasqueradeBit in kube-proxy Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it needs to be coordinated with other components, like kube-proxy, and the update will only be effective if MakeIPTablesUtilChains is enabled. Default: 14 |
iptablesDropBit
int32
|
iptablesDropBit is the bit of the iptables fwmark space to mark for dropping packets. Values must be within the range [0, 31]. Must be different from other mark bits. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it needs to be coordinated with other components, like kube-proxy, and the update will only be effective if MakeIPTablesUtilChains is enabled. Default: 15 |
featureGates
map[string]bool
|
featureGates is a map of feature names to bools that enable or disable alpha/experimental features. This field modifies piecemeal the built-in default values from "k8s.io/kubernetes/pkg/features/kube_features.go". Dynamic Kubelet Config (beta): If dynamically updating this field, consider the documentation for the features you are enabling or disabling. While we encourage feature developers to make it possible to dynamically enable and disable features, some changes may require node reboots, and some features may require careful coordination to retroactively disable. Default: nil |
failSwapOn
bool
|
failSwapOn tells the Kubelet to fail to start if swap is enabled on the node. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that setting it to true will cause the Kubelet to crash-loop if swap is enabled. Default: true |
containerLogMaxSize
string
|
A quantity defines the maximum size of the container log file before it is rotated. For example: "5Mi" or "256Ki". Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may trigger log rotation. Default: "10Mi" |
containerLogMaxFiles
int32
|
Maximum number of container log files that can be present for a container. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that lowering it may cause log files to be deleted. Default: 5 |
configMapAndSecretChangeDetectionStrategy
ResourceChangeDetectionStrategy
|
ConfigMapAndSecretChangeDetectionStrategy is a mode in which config map and secret managers are running. Default: "Watch" |
systemReserved
map[string]string
|
systemReserved is a set of ResourceName=ResourceQuantity (e.g. cpu=200m,memory=150G) pairs that describe resources reserved for non-kubernetes components. Currently only cpu and memory are supported. See http://kubernetes.io/docs/user-guide/compute-resources for more detail. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may not be possible to increase the reserved resources, because this requires resizing cgroups. Always look for a NodeAllocatableEnforced event after updating this field to ensure that the update was successful. Default: nil |
kubeReserved
map[string]string
|
A set of ResourceName=ResourceQuantity (e.g. cpu=200m,memory=150G) pairs that describe resources reserved for kubernetes system components. Currently cpu, memory and local storage for root file system are supported. See http://kubernetes.io/docs/user-guide/compute-resources for more detail. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may not be possible to increase the reserved resources, because this requires resizing cgroups. Always look for a NodeAllocatableEnforced event after updating this field to ensure that the update was successful. Default: nil |
reservedSystemCPUs
*
string
|
This ReservedSystemCPUs option specifies the cpu list reserved for the host level system threads and kubernetes related threads. This provide a "static" CPU list rather than the "dynamic" list by system-reserved and kube-reserved. This option overwrites CPUs provided by system-reserved and kube-reserved. |
showHiddenMetricsForVersion
string
|
The previous version for which you want to show hidden metrics.
Only the previous minor version is meaningful, other values will not be allowed.
The format is |
systemReservedCgroup
string
|
This flag helps kubelet identify absolute name of top level cgroup used to enforce `SystemReserved` compute resource reservation for OS system daemons. Refer to [Node Allocatable](https://git.k8s.io/community/contributors/design-proposals/node/node-allocatable.md) doc for more information. Dynamic Kubelet Config (beta): This field should not be updated without a full node reboot. It is safest to keep this value the same as the local config. Default: "" |
kubeReservedCgroup
string
|
This flag helps kubelet identify absolute name of top level cgroup used to enforce `KubeReserved` compute resource reservation for Kubernetes node system daemons. Refer to [Node Allocatable](https://git.k8s.io/community/contributors/design-proposals/node/node-allocatable.md) doc for more information. Dynamic Kubelet Config (beta): This field should not be updated without a full node reboot. It is safest to keep this value the same as the local config. Default: "" |
enforceNodeAllocatable
[]string
|
This flag specifies the various Node Allocatable enforcements that Kubelet needs to perform. This flag accepts a list of options. Acceptable options are `none`, `pods`, `system-reserved` & `kube-reserved`. If `none` is specified, no other options may be specified. Refer to [Node Allocatable](https://git.k8s.io/community/contributors/design-proposals/node/node-allocatable.md) doc for more information. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that removing enforcements may reduce the stability of the node. Alternatively, adding enforcements may reduce the stability of components which were using more than the reserved amount of resources; for example, enforcing kube-reserved may cause Kubelets to OOM if it uses more than the reserved resources, and enforcing system-reserved may cause system daemons to OOM if they use more than the reserved resources. Default: ["pods"] |
allowedUnsafeSysctls
[]string
|
A comma separated whitelist of unsafe sysctls or sysctl patterns (ending in ∗). Unsafe sysctl groups are kernel.shm∗, kernel.msg∗, kernel.sem, fs.mqueue.∗, and net.∗. These sysctls are namespaced but not allowed by default. For example: "kernel.msg∗,net.ipv4.route.min_pmtu" Default: [] |
volumePluginDir
string
|
volumePluginDir is the full path of the directory in which to search for additional third party volume plugins. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that changing the volumePluginDir may disrupt workloads relying on third party volume plugins. Default: "/usr/libexec/kubernetes/kubelet-plugins/volume/exec/" |
providerID
string
|
providerID, if set, sets the unique id of the instance that an external provider (i.e. cloudprovider) can use to identify a specific node. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may impact the ability of the Kubelet to interact with cloud providers. Default: "" |
kernelMemcgNotification
bool
|
kernelMemcgNotification, if set, the kubelet will integrate with the kernel memcg notification to determine if memory eviction thresholds are crossed rather than polling. Dynamic Kubelet Config (beta): If dynamically updating this field, consider that it may impact the way Kubelet interacts with the kernel. Default: false |
logging
*
LoggingConfiguration
|
Logging specifies the options of logging. Refer [Logs Options](https://github.com/kubernetes/component-base/blob/master/logs/options.go) for more information. Defaults: Format: text |
enableSystemLogHandler
bool
|
enableSystemLogHandler enables system logs via web interface host:port/logs/ Default: true |
shutdownGracePeriod
meta/v1.Duration
|
ShutdownGracePeriod specifies the total duration that the node should delay the shutdown and total grace period for pod termination during a node shutdown. Default: "30s" |
shutdownGracePeriodCriticalPods
meta/v1.Duration
|
ShutdownGracePeriodCriticalPods specifies the duration used to terminate critical pods during a node shutdown. This should be less than ShutdownGracePeriod. For example, if ShutdownGracePeriod=30s, and ShutdownGracePeriodCriticalPods=10s, during a node shutdown the first 20 seconds would be reserved for gracefully terminating normal pods, and the last 10 seconds would be reserved for terminating critical pods. Default: "10s" |
SerializedNodeConfigSource allows us to serialize v1.NodeConfigSource. This type is used internally by the Kubelet for tracking checkpointed dynamic configs. It exists in the kubeletconfig API group because it is classified as a versioned input to the Kubelet.
| Field | Description |
|---|---|
apiVersion string |
kubelet.config.k8s.io/v1beta1 |
kind string |
SerializedNodeConfigSource |
source
core/v1.NodeConfigSource
|
Source is the source that we are serializing |
string
alias)HairpinMode denotes how the kubelet should configure networking to handle hairpin packets.
(Appears in: KubeletAuthentication)
| Field | Description |
|---|---|
enabled
bool
|
enabled allows anonymous requests to the kubelet server. Requests that are not rejected by another authentication method are treated as anonymous requests. Anonymous requests have a username of system:anonymous, and a group name of system:unauthenticated. |
(Appears in: KubeletConfiguration)
| Field | Description |
|---|---|
x509
KubeletX509Authentication
|
x509 contains settings related to x509 client certificate authentication |
webhook
KubeletWebhookAuthentication
|
webhook contains settings related to webhook bearer token authentication |
anonymous
KubeletAnonymousAuthentication
|
anonymous contains settings related to anonymous authentication |
(Appears in: KubeletConfiguration)
| Field | Description |
|---|---|
mode
KubeletAuthorizationMode
|
mode is the authorization mode to apply to requests to the kubelet server. Valid values are AlwaysAllow and Webhook. Webhook mode uses the SubjectAccessReview API to determine authorization. |
webhook
KubeletWebhookAuthorization
|
webhook contains settings related to Webhook authorization. |
string
alias)(Appears in: KubeletAuthorization)
(Appears in: KubeletAuthentication)
| Field | Description |
|---|---|
enabled
bool
|
enabled allows bearer token authentication backed by the tokenreviews.authentication.k8s.io API |
cacheTTL
meta/v1.Duration
|
cacheTTL enables caching of authentication results |
(Appears in: KubeletAuthorization)
| Field | Description |
|---|---|
cacheAuthorizedTTL
meta/v1.Duration
|
cacheAuthorizedTTL is the duration to cache 'authorized' responses from the webhook authorizer. |
cacheUnauthorizedTTL
meta/v1.Duration
|
cacheUnauthorizedTTL is the duration to cache 'unauthorized' responses from the webhook authorizer. |
(Appears in: KubeletAuthentication)
| Field | Description |
|---|---|
clientCAFile
string
|
clientCAFile is the path to a PEM-encoded certificate bundle. If set, any request presenting a client certificate signed by one of the authorities in the bundle is authenticated with a username corresponding to the CommonName, and groups corresponding to the Organization in the client certificate. |
string
alias)(Appears in: KubeletConfiguration)
ResourceChangeDetectionStrategy denotes a mode in which internal managers (secret, configmap) are discovering object changes.
Generated with gendoc
on git commit 5cc67040


The output file is located in the same directory as the first input file. The exact path will be shown in the form as well as a list of all input files that have been merged.
| Previous | Next | See Also |
This form displays the output of the PRIDE XML merger.
The output file is located in the same directory as the first input file. The exact path will be shown in the form as well as a list of all input files that have been merged.


We are Khurafati's who love to make some amazing products and help the community to do our part and give something back to it. This is our first product under the new umbrella of Khurafat Studio which is going to be a community of developers who wants to give something back with their skills and create things that millions might use.
Although, we are very passionated to build this product and many others but we certainly can use more hands and maybe more experienced hands to help us out and be a part of a team that might be off to something. Just reach out at<EMAIL_ADDRESS>to get in.


-
Each config file contains zero or more sections containing zero or more entries:
| [Section1]
| key1 = 1
|
| [Section2]
| key1 = 2
-
Unicode escapes can be used in values.
| key1 = \u0070\u0075\u0062\u006c\u0069\u0063
-
Comment lines start with the '#' character and can be placed on lines before sections and entries:
| # A comment about this section
| [Section1]
|
| # A comment about this entry
| key1 = 1
-
Comments can also be placed on the same line as entries:
| key1 = 1 # A comment about this entry
-
Values containing '#' must be escaped to prevent identification as a comment character:
| valueContainingPound = Value containing \u0023 character
Likewise, '\' should be escaped to prevent confusion with unicode escapes.
-
Values containing newlines can span multiple lines.
Subsequent lines start with a tab character.
| multiLineValue =
| line 1,
| line 2,
| line 3
When retrieved, the above translates to "line1,\nline2,\nline3".
-
Leading and trailing whitespace on values are ignored.
-
Whitespace is not ignored within multi-line values (except for the leading tab character on each line).
-
Blank lines can be used anywhere in the file.
| # A comment line
|
| # Another comment line
| [Section1]
| ...
-
Values located before any sections are considered part of the no-name section, meaning
they are accessed simply by key and not section/key.
| # Top of file
|
| # Use config.getString("key1") to retrieve.
| key1 = val1
|
| # The first section
| [Section1]
|
| # Use config.getString("Section1/key2") to retrieve.
| key2 = val2
-
Section and key names must be at least one character long and not consist of any of the following
characters:
| / \ [ ] = #
-
Whitespace in section and key names is technically allowed but discouraged.


Minimalist social sharing jQuery plugin, use any styles, themes, buttons or links. Includes templates and callbacks for popup `open` and `close` events.
This demo uses the Zocial CSS social buttons and Bootstrap for presentation purposes, these are not required and you can use the plugin without them.
Full documentation on GitHub's readme.
Set a CSS class to the element that matches a template.
Set a data-jqss-price-selector data attribute to get the price from another element.
$(function () {
$.fn.jqss.templates['custom'] = 'https://custom.com?u={{URL}}&t={{TITLE}}';
$(".social-container a").jqss({
url:'https://github.com/pnmcosta/jquery-socialshare'
});
});


This doesn't seem to be working. When I highlight a server in my server history tab it doesn't display users that are connected and currently on my radar. Any chance we can get it added? Thanks
BrainFooLong
Administrator
For me this does work fine.
Have you tried visiting the server detail page of you see there the radar user red highlighted?
If it also doesn't work here, have you enabled the "soldier radar", if yes, have you tried it with another browser?
And which browser do you use, which addon version do you use?
More information for a bug report is required toh elp you.


QUIN Delivers Dreamy New Single "7th Heaven"
QUIN's new project is on the way.uot
by Aron A.7th Heaven
QUIN
Editor Rating: HOTTTTT
User Rating: meh - 44% (4)
Los Angeles' QUIN has been quietly making noise from the West Coast and beyond over the past few years. Releasing her projects GALACTICA and DREAMGIRL in 2016 and 2017, respectively, served as a formal introduction to her but since it's been two years since her last release, fans have eagerly awaited the release of her next project. Thankfully, they won't have to wait too long and ahead of its release, she blesses fans with her latest drop, "7th Heaven."
QUIN takes fans on a journey through the galaxy on her latest track. The follow-up to February's "Mushroom Chocolate" with 6lack is soulful with her airy vocals floating atop the dreamy production before fading away.
QUIN's getting ready to release her new project, LUCID on November 15th. Keep your eyes peeled.


The Occupy Wall Street movement failed because it was demanding power but never realizing that they had it all along.
Over the last century, and through some brilliant manipulation based on psychology, consumerism has become therapeutic and fills many people's emotional needs.
Feel bad? Go shopping for new clothes! You'll feel like a whole different person.
This attitude allowed corporations to get so massive that they now hold Congress in check.
The solution is so simple yet extremely difficult to do.
It will probably be easier for me, because I've always been poor, but nevertheless, I will start a silent protest with the only capital I have: My mind and my hands.
I will not buy new clothing, or shoes, or unnecessary snacks, for two entire years. I refuse to play this game.
I will make art out of my clothing, I will put it in my face, and thereby challenge the artists of the fashion industry.

With our bare eyes, humans are not aware of the complexities of the universe. We use tools to see particles, to see the other wavelengths of light, to see the beginning of time.
If I want to study the power of observation and perception, what better place to start than by wearing and becoming art?
When art is carried within a person, people notice. Political statements are made. Gaga used it as a mask that one had to see past in order to realize how unique her essence was.
Kahlo used her body as a way to claim her authenticity and stay true to her essence.
It's funny how I realize that I've played this game all along. By wearing black, I expose only one thing: the person behind the clothing. Some choose to not see past that.
But I can do more than that.
This is just an experiment
Heinsenberg's Uncertainty Theorem states that we cannot know both position and momentum of particles at the same time. Why should this be so?
Back of the envelope calculations tell us that the speed of light and the energy transmitted during the act of observation hold the answer to this conundrum.
What occurs during this act of observation? Light enters the retina of a conscious being, and thus either position or momentum is fixed at that particular moment.
I cannot pretend to know the answers just yet, but I will experiment with the question and its consequences in my future art.
The current big quest in physics is to unify the laws of the quantum world with those of relativity and the macro world. String theory proposes that quarks, the building blocks of protons and neutrons in the nucleus of all atoms, otherwise known as hadrons, are not the smallest constituents. String theorists argue that quarks, and all fundamental matter, hold within them vibrating strings which hold multiple dimenstions.
There is a twinge of humor in this whole affair that perhaps means nothing, but perhaps can explain why string theory doesn't seem to fit just right.
Gell-Man's creative flair in naming quarks was a tad bit problematic. He obtained that term from a novel by James Joyce. Joyce, an author who played with our imagination and the power of interpretation.
Consider his novel Ulysses. It's a world of its own. The characters just are. Living, breathing, mundane in the perfect sense. There is only one meaning to his novel, and it is what the reader makes it to be.
See the humor now? Naming fundamental particles after a term by Joyce. Of course quarks are so mysterious!
But just as Joyce comes to life when read, so does the quantum world. Maybe God does play with dice after all.
It's a game from now on: who can reach the hidden layer beneath the form of quarks, beneath the form of Joyce? There one must search.
I have a clearer picture of what I must do, but first I must explain the most important piece I've done.
Acrylic over cork, with a hidden paper curve that held my past. A 'foregiveness letter' in therapized terms.
My past is engrained in this piece, but so is my future. Even then, I knew that perfect symmetry was not ideal, that realism wasn't enough, that life could spring forth from my fingers.
I can move on now.
...
With my future work I intend to explore the power of perception, the unification of the quantum and the macro, and the source of light and life.
I'm in for the ride of my life.
First of all, I underappreciated the understanding of the Greeks. They too knew that irrationallity was the source of beauty, as evidenced by their frequent use of the golden ratio, an irrational number.
Duchamp said that art should be at the service of the mind, and Shoenberg experimented with atonality to create his haunting works.
Art should be more than beautiful: It must create understanding on its own. It must be like the Large Hadron Collider, and act as a vessel to understand the richness of the universe.
That means that it does not necessarily fit into our intuitions and expectations of beauty and rationality. A relative looking glass that gives birth to new ideas.
Time to get my hands dirty.
About a year and a half ago, I wrote a poem which I named Escaping the Chaos. Here it is.
Wind pushes the fringes of the scene The air tastes like earth and mist Water intermixed with trees, fixating on all surfaces. The boundaries of the storm curve along a cave, A space holding the connections that perceive all. Swirl, swirl, little breeze Until you become a hurricane. The entrails of the burrow are scraped and battered There end is nowhere near. There! There is the solution! The tumbling air came to a still as the machine picked up the utensil. Hold it, liberate the chaos through your appendages. Pure energy ebbs through the rails, Until the final destination is covered in scratches. Hurry, hurry now! The flow continues now until it all starts shaking. The water pours, fills in the crevices deep in the ultimate surface. Nobody bears witness of the magic, nobody hears the flow of rushing waves. The machine is on automatic, long ago programmed and now left as obsolete. It runs its course, for otherwise destruction is eminent. The storm calms its intensity. The machine is spent, worn, yet serene as the now still waters. It opens its eyes, and lets out a sigh.
I must change the title, for now I know that chaos is what fueled the machine's production. It allowed creation.
There is a fear of chaos enrapturing me again, but I shall plunge into it.
That will prove my courage to myself and the universe.
Warmth curses through me.
Nature creates a beauty that is appreciated by humans through the use of irrationality.
Yet humans are so captivated by the form, by the symmetry, that they often fail to see the essence.
It is not intristic in human nature to look past the veil.
When I began drawing, I wanted beauty. I wanted my work to be realistic as possible, for I deemed that perfection.
But I was wrong. I have to explore irrationallity, dissonance, and chaos, for theirin lies beauty.
Essence cannot be overcome by form.
Now that my health is returning, I will do anything in my power to never again let it define me. My will shall control
The unification of physics, mathematics, philosophy and art. A task that perhaps only nature can undertake, but I will nevertheless attempt.
The first questions I will explore are: Is symmetry really the absolute perfection? The Greeks certainly thought so, and modern physicists strive to prove supersymmetry. But is it realistic?
Music is deemed more beautiful when the rations are well proportioned. Faces with near perfect symmetry are the ideal. 1:1, 1:2, 2:1, 2:2. On it goes.
But then there is pi. Not the most rational of the ratios, yet it is the one that nature uses the most. The most irrational ration is fundamental to the epitomy of symmetry: the circle.
Symmetry is not perfection.
I was a baby elephant at the circus my entire life. Looping around a circle on a rope. I set my focus high in an attempt to escape, but once the rope was cut, I kept on circling. Depression, panic disorder, and PTSD. Do real elephants get these illnesses too?
I had the sky before me but my mind refused to fly. I had to step outside the circle, but my ambiguity led me to hospitalization. Medication.
Now it is clear.
I want to test all limits, of myself and those of society. The challenger. The unifier of mathematics, physics, philosophy, and art.
The supplanter.
Watch me singe my hair with the heat of the sun.