**Lint Development Guidelines** (This folder should also contain architectural information documents.) # Setup To develop lint, use a recent IntelliJ, check out the Android tools repository and then open up the folder `tools/` as a Gradle project. # Code * All new files should be written in Kotlin. * Code should be formatted using “cd lint && gradle formatLint”, which will format both the Java and Kotlin files according to the configured style. * All lint checks must have tests checking both for false positives and false negatives. * Make sure that lint checks have the correct platform applied (e.g. androidSpecific=true in the issue registration for any Android checks.) # Debugging lint under Gradle To be able to attach to and debug lint when invoked from within the Android Gradle plugin, add this to the `gradle.properties` file in the target project before invoking gradle with the debug flags: ``` android.experimental.runLintInProcess=true ``` # Debugging lint in the IDE By default the IDE cancels certain operations if they take too long, including Lint. This makes debugging tricky. To disable this behavior, start the IDE with ``` -Didea.ProcessCanceledException=disabled ```` Alternatively, you can use the internal action "Disable ProcessCanceledException". Note, to use internal actions you must first go to `Help > Edit Custom Properties` and add ``` idea.is.internal=true ``` # Updating Baselines If you've added a new lint check which has a number of existing violations in the Studio tree, you can run the following target to update the baselines: ``` bazel run --test_env=UPDATE_LINT_BASELINE=1 \ $(bazel query --output=label 'kind(.*lint_test, //tools/...)') ``` # Registering Inspections When lint runs in the IDE, all lint checks are wrapped as IntelliJ inspections, such that they show up in the Inspections options list etc. Lazily discovered lint checks (3rd party lint checks) will show up as soon as lint has run to discover them, but for built-in checks we should register them in advance such that they always show up. To do this, open the `tools/adt/idea` project and run the `LintInspectionRegistrationTest` test. To have your sources updated in place, either set `$ADT_SOURCE_TREE` or edit the test first to point the `sourceTree` var to point to your checkout. # Deprecating and Removing APIs If we have to remove methods (such as `UastContext`, which is slated for removal from UAST in the next version of IntelliJ), just deprecating doesn't seem to be enough; a lot of existing lint checks will use APIs if the code continues to compile and run. We are guilty of this ourselves; lint itself is still referencing a lot of deprecated APIs. However, if we just delete APIs, that will break existing lint checks in the field. Therefore, to deprecate APIs, we should be using Kotlin's special support for marking deprecated methods hidden (the `DeprecationLevel` attribute in a `Deprecated` annotation). This will keep the method in the runtime jar file, and older lint checks will be able to invoke it -- but it's removed from compilation, therefore forcing lint checks to update before we actually remove the API for good. (This support is one of the reasons why we want all new APIs in lint to be implemented in Kotlin.) # Issue Granularity We regularly get requests for a new lint check to highlight or discourage one specific method. Here's some discussion from the most recent time this came up, which might provide some insights into how we think about this: Generally, if an issue is “just” data, we shouldn't give it its own issue id. Each issue id is configured separately (in lint.xml files), shows up independently in the inspections UI in Studio, and it's a global namespace. Most of the API-specific lint checks are doing something more subtle; for example, the ToastDetector makes sure that if you call `makeText()`, you end up calling `show` on the resulting object, even if indirectly. Similarly, `AlarmDetector` is specific to the `setRepeating()` method on `AlarmDetector`, but it does data analysis to figure out if the parameter passed as the duration is not long enough. (There might be a few examples where we do have a lint check dedicated to a specific API but if we do, we regret those...) For simple discouraged APIs, we have several approaches: 1. (Best) Create a new annotation, for example @Discouraged, which we put in the support library and we then annotate all the platform calls we want to discourage users from. We then have a detector which looks for this annotation and flags any uses of it. There are many detectors like this in lint already, enforcing a wide range of annotations. The discourage-message could be part of the annotation metadata. 2. Like (1), but instead of annotations, with bundled data. For example, lint's API check works this way; it ships with a database of API “since” info that it uses for enforcement.  Like (2), but the data is bundled directly as code/lists/arrays within the check: Create a shared detector which has a hardcoded list of APIs that we're enforcing. For example, for lint checks that run against Studio's own codebase, we have this detector which has a denylist of certain APIS we don't want used: https://source.corp.google.com/android/tools/base/lint/studio-checks/src/main/java/com/android/tools/lint/checks/studio/ForbiddenStudioCallDetector.kt In lint itself, there is a similar check, dedicated to deprecations: https://cs.android.com/android-studio/platform/tools/base/+/mirror-goog-studio-main:lint/libs/lint-checks/src/main/java/com/android/tools/lint/checks/DeprecationDetector.kt;l=1?q=DeprecationDetector.kt The DeprecationDetector is used to flag APIs that are discouraged. It was initially written to let us deprecate things in XML files (since java and Kotlin have their own existing facility for providing warning messages for discouraged APIs). However, since then we've actually added Java/Kotlin specific calls, where we really want to not just say “deprecated” but to customize the specific error message -- see the Firebase/JobScheduling messages. And note that as of Arctic Fox you can actually vary the severity on a per incident basis too, so you can pick warning or error as default based on the specific check. # Informational Checks Lint checks should pinpoint a problem. They are not intended to only be educational or to just "bring awareness" around recent changes to an API. Especially if the lint check cannot check whether the guidance applies, for example because it depends on policy approval which is not available for inspection in the code. A check which unconditionally flags code in order to educate users is often considered by users to be "spammy". We've had some checks like that in the past, and they were not popular, and the issue id soon ended up in default ignore rules for lint. For an example, see [this StackOverflow thread](https://stackoverflow.com/questions/34173545/missing-support-for-fireb ase-app-indexing-android-lint).


The official definition of git is "a distributed version control system". But what does it mean? Let's use an example to explain it.
In the next table we have some changes we did to a file:
| Time | Status |
|---|---|
| July 7, 10:00 | Create file tasks.txt. |
| July 7, 10:05 | Add paragraph to file tasks.txt. |
| July 7, 10:10 | Format the content of tasks.txt. |
| … | … |
We can think of every row in the table as a version of the file. So git is a system that helps us track version or changes of files through time (it is also distributed, but that's a feature for another tutorial).
To initialize git inside a folder, we use the command git init. After executing this command, git will start tracking changes inside the folder.
Internally git have three states (also called areas) where changes can be in: working directory, staging area, and repository.
Click the next button to start the animation.
git initThe first thing we need to see git in action, is a file. We can create a new file with the command touch and passing a filename as the first argument (this is a UNIX command not a git one).
This command will create the file tasks.txt. In this file we will keep a list of tasks we need to do.
The working directory area tracks all changes we make inside the folder. So git will show this new file inside this area.
touch tasks.txtA commit is a change, or a group of changes, we wrap together and tell git to save. It is created in 2 steps: the first one is adding all the changes we want to the staging area.
To add changes to the staging area we use the command git add. The next command moves the changes of the file tasks.txt from the working directory to the staging area.
git add tasks.txtBefore, we saw the first of the 2 steps to create a commit.
The second step is explicitly telling git to wrap all the changes currently in the staging area into a commit node. We do this with the command git commit.
We give each commit a message to easily identify its contents later. To pass a message to git commit we use the option –m.
The next command will create our first commit with the message Add file tasks.txt.
git commit –m "Add file tasks.txt"The echo command mixed with >> adds lines to the end of a file.
The first task we want to do is to Buy milk. So we will add it to our file tasks.txt with the echo command.
Look how git tells us that the file has changed by adding it to the working directory area.
echo "Buy milk" >> tasks.txtAnother useful command is git status. This command shows us the changes we have inside the working directory and the staging area.
Look at the output of the command in the console (bottom left). git status will tell us that the changes are not staged (this means that the changes are inside the working directory). All the files with changes inside the working directory will be shown in red. And the file tasks.txt has a modified status because we add a line to it in the last step.
git statusThe command git status just shows us the names of the files with changes. If we want to know what changed inside each file of the working directory, we can use the command git diff.
In the output of git diff, the lines that we added to the file are shown in green, and the ones that we removed are shown in red.
git diffWe want to create another commit with the changes we did to tasks.txt. We need to add the changes to the staging area again with the command git add.
git add tasks.txtWe can use the command git status again to see the message git gives us when we have staged changes. The file tasks.txt still appears with a modified status, but the color has changed to green which means the changes are inside the staging area.
git statusIn step 7 we used the command git diff to see the detailed list of changes we had inside the working directory.
This command can also show the changes inside the staging area, if we pass the option ––cached to it.
The output has the same color code: the lines that we added are shown in green, and the ones that we removed are shown in red.
git diff ––cachedWe want the changes in the staging area to be a new commit.  This command shows us the commits we have made.
git log has various options to show the output with different detail levels. We use the option ––oneline to see the output in a short format.
git log ––onelineThis tutorial has all the basic commands you need to start using git in your personal projects.
There is a lot more to learn about git, look at the Resources section for a list of next steps to expand your knowledge of git.
Also you can use the Cheatsheet section as a reference. It has all the commands in this tutorial with explanations for the most used options.


×
Incident Type
Name
*
Please enter Name
Description
*
Please enter Description
Keywords
Order No
-- Select Order No --
Tool Tips Description
Incident Sub Type
Add Sub Incident
Sub Incident Name
Description
Is Specified
Order No
No results found
Edit
Delete
{{subIncident.incident_sub_type_name}}
{{subIncident.description}}
{{subIncident.is_specify}}
{{subIncident.order_no}}


Double Team (1997) A movie review by Serdar Yegulalp (C) 1997 by Serdar Yegulalp
CAPSULE: Trippy, hyperspeed action machine from Hong Kong's accomplished Tsui Hark. Van Damme and Rodman have nice chemistry, the stunts are eyepopping, and stuff gets blowed up real good; what more do you want?
I admit I was all set to loathe DOUBLE TEAM; it reeked of cheapjack timing-oriented marketing (stick Dennis Rodman in a movie, quick, while he's hot, and do something about Jean-Claude Van Damme's flagging career while we're at it!).  Bring some friends, get some pretzels, and have a blast.
 But Van Damme's character has a pregnant wife who's also a sculptor, and some unpleasant pressure gets used to get him to come through on this mission. He's been assigned to take down an old enemy, a terrorist named Stavros (Mickey Rourke, looking oddly subdued), who may be back up to his old tricks.
In the first showdown between Quinn and Stavros, the movie wears its ambitions proudly on its sleeve: nonstop action. An amusement park, a hospital, a private "retired spy"'s retreat, most of Rome, various houses, planes, cars and other modes of transport, and the Coliseum (!) all become arenas for some of the most bone-rattling shoot-outs and punch-outs filmed. They are better seen than described and are reason enough to see the film: one jaw-dropping scene has Van Damme taking on a man who uses a switchblade with his *feet*. (Van Damme is a good, dextrous athlete and fighter, but he is often upstaged.)
There are other nice touches. Stavros and Quinn both want the same thing: to retire in peace with their families. That ambition ties them together in various ways, and also humanizes them a bit. One of the things about HK action movies is that there's always some form of human element, and that's carried over into this movie as well. It gives weight to scenes that would otherwise be forgettable. Also good is Dennis Rodman, playing a weapons dealer named Yaz -- a character who sticks out like a fistful of broken fingers and who is funny just standing there. Rodman is natural on screen; he's fun to watch, especially when slinging bad guys like basketballs, and deserves to get a movie of his own, based on what's seen here: a lightweight, fast-moving entertainment that showcases all of its pieces excellently.
Three out of four man-eating tigers.
<EMAIL_ADDRESS>EFNet IRC: GinRei http://www.io.com/~syegul another worldly device... you can crush me as I speak/write on rocks what you feel/now feel this truth =smilin' in your face, all the time wanna take your place, the BACKSTABBERS=
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Preparation time
30 mins to 1 hour
Cooking time
10 to 30 mins
Serves
Serves 2-4
Take a trip to a Chinese supermarket to pick up the ingredients for this quick and delicious meal.
For the glutinous rice, rinse the rice in bowls of water until the water runs clear (to remove the excess starch).
Place in a pan with 600ml/1 pint water. Bring to the boil, then reduce the heat, cover and simmer for 15 minutes. Ensure all the water has evaporated before using.
For the lotus leaf parcels, heat a wok over high heat until it begins to smoke, then add the peanut oil.
Add the ginger, shallots, chopped shrimps and mushrooms and stir-fry for one minute.
Add the pork belly and stir-fry to break it up. When the pork begins to brown, stir in the five-spice and rice wine (or sherry). When the wine has almost evaporated, stir in the cooked rice.
Once the rice is incorporated, season with the soy sauce, the sesame oil, salt and white pepper and mix well. Remove from the heat.
Pat the lotus leaves dry using kitchen paper.
Spoon half of the sticky rice mixture into the centre of one lotus leaf.
Fold in the sides (snug, but not tight), fold up the bottom and roll up, then secure with cooks' string.
Repeat with the remaining lotus leaf and rice.
Place in a bamboo steamer and steam for 10 minutes until the fragrance has infused.
Remove from the steamer and untie the parcels
For the pak choi stir fry, heat a wok until hot, then add the garlic, ginger and chilli and stir fry for one minute.
Add the pak choi and stir fry for another minute then add the remaining ingredients and stir fry for 1-2 minutes until the pak choi has just wilted and is hot.
To serve, place the parcels on a serving plate with pak choi alongside and garnish with the sliced spring onions.


Bonfire:
Server Monitor
Empower server owners and developers to manage and control the use of Cloudflare™ proxied sites & web resources without being chained to a computer.


My Activity
Filter Option
Order Information
- My Orders
- View Detail
- Orders#:100000177
- Order status:processing
| Order Date: | October 27,2015 | Payment Method: | Debit Card | |||||||||
| Shipping Address: |
|
Shipping Address: |
|
|||||||||
| Shipping Method: | United Parcel Service- 3 day Select |
Item Ordered
- Bidders:14
- Bids:14
- Expiration:1 day 15 hours 21 mins
| bidder | SKU | price | QTY | sub total |
|---|---|---|---|---|
| Blue Cort | Blue Cort | 27-Nov-2015 15:06:56 CST | 2 | $690.00 |
| Shirt | Shirt | 27-Nov-2015 15:06:56 CST | 2 | $690.00 |
| Iphone 6S | Iphone 6S | 27-Nov-2015 15:06:56 CST | 2 | $690.00 |
Sub Total:$2070.00
Grand Total:$2070.00


A spectral binning approach for high resolution flow infusion mass spectrometry data.
| Version: | 2.0.5 |
| Imports: | dplyr, magrittr, mzR, plyr, tidyr, methods, purrr, stringr, tibble, crayon, cli, lubridate, ggplot2, ggthemes |
| Suggests: | knitr, rmarkdown, gridExtra, metaboData (≥ 0.2.3), prettydoc, htmltools, covr, testthat, gifski |
| Published: | 2018-12-12 |
| Author: | Jasen Finch [aut, cre] |
| Maintainer: | Jasen Finch <jsf9 at aber.ac.uk> |
| License: | GPL (≥ 3) |
| URL: | https://github.com/jasenfinch/binneR |
| NeedsCompilation: | no |
| CRAN checks: | binneR results |
| Reference manual: | binneR.pdf |
| Vignettes: |
binneR |
| Package source: | binneR_2.0.5.tar.gz |
| Windows binaries: | r-devel: binneR_2.0.5.zip, r-release: binneR_2.0.5.zip, r-oldrel: binneR_2.0.5.zip |
| OS X binaries: | r-release: not available, r-oldrel: binneR_2.0.5.tgz |
| Old sources: | binneR archive |
Please use the canonical form https://CRAN.R-project.org/package=binneR to link to this page.


The world wide web is a collection of Html documents accessed via the internet. When a person accesses a web browser such as internet explorer or firefox to access a webpage i.e yahoo.com, their computer sends a HTTP request to a server. The server then delivers the web page to the web browser via the Internet. This HTML document is then displayed on the user's computer.
A browser is known as a computer program used to find a view information on the Internet
"Hypertext Transfer Protocol" better known as HTTP, is the main protocol of the web. The browser uses Http to communicate with the servers.
A Server is like a little apartment housing all the webpages. The server interprets the Html tags and sends them back as a webpage to our browser.
"Hyper Text Markup Language" better known as HTML, is the basis for almost every webpage
Tags are always contained within an angled bracket. An element is everything within a set of opening and closing tags. Html elements are either inline or block. Block just means there is an invisible box around the content.The invisible block can be a certain height and width
Attributes are anchors used for referencing hyper links
Document Object Model is referred to a tree-like structure of a page. Viewing this structure in a browser, it will show as a series of nested boxes.
Everything on a webpage is in a box. There are also boxes within boxes. The more indented an element is, the deeper the nest box.
Writing a code can be difficult. Text editing programs like Sublime Text to assist in code writing. Sublime Text will automatically generate a closing HTML tag when you input an opening tag.
Cascading Style Sheets - style sheet language used for describing the look and formatting of a document written in a markup language.
Repetition is one of the main things you have to look out for. People have a tendency to make mistakes and not be consistant.


Logout
Edit Ticket
Home
All tickets
Ticket ID
Date created
Description
Bug finder
Assigned developer
Comment
Status
1
10th March 2021
The API does not connect to the DB
Kevin Kariuki
Joseph Mumbi
Connection to be resolved by checking the db link
Open


NEW NC (NON CONFORMITY)
Title
Operator Auditee
Number
Date
Status
Agreed date for CAP(Corrective Action Plan)
Level
Due date
Closure date
Requirement references
Further references
Auditor of CAA
Auditee responsible for CAP
Requirement References:
Non Conformity Details:
Add level descriptions:
Item One
Item Two
Item Three
New CA


High Priest Marie:
Greetings, young seeker! I am but a humble servant of the Creator Einhasad, whose sole purpose is passing on her divine wisdom. I am merely an instrument in proclaiming her sacred teachings to the world.
Listen to information about first class transfer.
Clan.
Alliance.
Quest.


hashtable_at(h, key, default = false)
Return the value associated with key
in the hash table h
.
Return the value of default
if no association is found.
Key
should be of the appropriate type expected by the hash and equivalence functions specified when creating the
hash table. Default
may be any object.
let h = #{1:2, 3:4}
hashtable_at(h, 1)
// 2
h[3]
// 4
hashtable_at(h, 10, 123)
// 123


Before Change
def _forward_lama(self, state, action):
state_ = state
if len(state_.shape) < 3:
state_ = state_.unsqueeze(1)
if isinstance(self.observation_net, nn.Module):
batch_size, history_len, feature_size = state_.shape
state_ = state_.view(-1, feature_size)
state_ = self.observation_net(state_)
state_ = state_.view(batch_size, history_len, -1)
state_ = self.aggregation_net(state_)
// @TODO: add option to collapse observations based on action
action_ = action.view(action.shape[0], -1)
After Change
x = self.main_net(x)
return x
def _forward_lama(self, state, action):
state_ = self._process_state(state, self.observation_net)
state_ = self.aggregation_net(state_)
action_ = self.action_net(action)
x = torch.cat((state_, action_), dim=1)
x = self.main_net(x)


I find myself advocating for better refactoring more and more. Here are some links and resources that help you learn how.


Dependency network measures capture various facets of the dependencies among software modules. For example, betweenness centrality measures how much information flows through a module compared to the rest of the network. Prior studies have shown that these measures are good predictors of post-release failures. However, these studies did not explore the causes for such good performance and did not provide guidance for practitioners to avoid future bugs. In this paper, we closely examine the causes for such performance by replicating prior studies using data from the Eclipse project. Our study shows that a small subset of dependency network measures have a large impact on post-release failure, while other network measures have a very limited impact. We also analyze the benefit of bug prediction in reducing testing cost. Finally, we explore the practical implications of the important network measures.


@* * Copyright 2021 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @import play.api.data.Form @import uk.gov.hmrc.incometaxsubscriptionselfemployedfrontend.forms.individual.BusinessTradeNameForm._ @import uk.gov.hmrc.play.views.html.helpers.form @import uk.gov.hmrc.incometaxsubscriptionselfemployedfrontend.config.AppConfig @import uk.gov.hmrc.incometaxsubscriptionselfemployedfrontend.models.BusinessTradeNameModel @import uk.gov.hmrc.incometaxsubscriptionselfemployedfrontend.views.html.templates.main_template @import uk.gov.hmrc.incometaxsubscriptionselfemployedfrontend.views.html.helpers._ @(businessTradeNameForm: Form[BusinessTradeNameModel], postAction: Call,isEditMode: Boolean, backUrl: String)(implicit request: Request[_], messages: Messages, appConfig: AppConfig) @main_template(title = messages("business.trade_name.title"), form = Some(businessTradeNameForm)) { @back_link(backUrl) @summaryErrorHelper(businessTradeNameForm)
@messages("business.trade_name.hint")
@form(action = postAction) { @inputHelper( field = businessTradeNameForm(businessTradeName), label = Some(Messages("business.trade_name.heading")), labelClass = Some("visuallyhidden"), maxLength = Some(businessTradeNameMaxLength), parentForm = businessTradeNameForm ) @if(isEditMode) { @continueButton(Some(messages("base.update"))) } else { @continueButton() } } }


Here are the records of th Department table
{% if dept %}
Department ID
Department name
{% for d in dept %}
{{d.dept_id}}
{{d.dept_name}}
{% endfor %}
{% else %}
No department records found.
{% endif %}


To use the Rocco Rake tasks, require rocco/tasks
in your Rakefile
and define a Rake task with rocco_task
. In its simplest form, rocco_task
takes the path to a destination directory where HTML docs should be built:
require ‘rocco/tasks’
desc “Build Rocco Docs”
Rocco::make ‘docs/’
This creates a :rocco
rake task, which can then be run with:
rake rocco
It’s a good idea to guard against Rocco not being available, since your Rakefile will fail to load otherwise. Consider doing something like this, so that your Rakefile will still work
begin
require ‘rocco/tasks’
Rocco::make ‘docs/’
rescue LoadError
warn “#$! — rocco tasks not loaded.”
task :rocco
end
It’s also possible to pass a glob pattern:
Rocco::make ‘html/’, ‘lib/thing/**/*.rb’
Or a list of glob patterns:
Rocco::make ‘html/’, [‘lib/thing.rb’, ‘lib/thing/*.rb’]
Finally, it is also possible to specify which Pygments language you would
like to use to highlight the code, as well as the comment characters for the
language in the options
hash:
Rocco::make ‘html/’, ‘lib/thing/*/.rb’, { :language => ‘io’, :comment_chars => ‘#’ }
Might be nice to defer this until we actually need to build docs but this will have to do for now.
require 'rocco'
Reopen the Rocco class and add a make
class method. This is a simple bit
of sugar over Rocco::Task.new
. If you want your Rake task to be named
something other than :rocco
, you can use Rocco::Task
directly.
class Rocco
def self.make(dest='docs/', source_files='lib/**/*.rb', options={})
Task.new(:rocco, dest, source_files, options)
end
Rocco::Task.new
takes a task name, the destination directory docs
should be built under, and a source file pattern or file list.
class Task
include Rake::DSL if defined?(Rake::DSL)
def initialize(task_name, dest='docs/', sources='lib/**/*.rb', options={})
@name = task_name
@dest = dest[-1] == ?/ ? dest : "#{dest}/"
@sources = FileList[sources]
@options = options
Make sure there’s a directory
task defined for our destination.
define_directory_task @dest
Run over the source file list, constructing destination filenames and defining file tasks.
@sources.each do |source_file|
dest_file = source_file.sub(Regexp.new("#{File.extname(source_file)}$"), ".html")
define_file_task source_file, "#{@dest}#{dest_file}"
If rake/clean
was required, add the generated files to the list.
That way all Rocco generated are removed when running rake clean
.
CLEAN.include "#{@dest}#{dest_file}" if defined? CLEAN
end
end
Define the destination directory task and make the :rocco
task depend
on it. This causes the destination directory to be created if it doesn’t
already exist.
def define_directory_task(path)
directory path
task @name => path
end
Setup a file
task for a single Rocco output file (dest_file
). It
depends on the source file, the destination directory, and all of Rocco’s
internal source code, so that the destination file is rebuilt when any of
those changes.
You can run these tasks directly with Rake:
rake docs/foo.html docs/bar.html
… would generate the foo.html
and bar.html
files but only if they
don’t already exist or one of their dependencies was changed.
def define_file_task(source_file, dest_file)
prerequisites = [@dest, source_file] + rocco_source_files
file dest_file => prerequisites do |f|
verbose { puts "rocco: #{source_file} -> #{dest_file}" }
rocco = Rocco.new(source_file, @sources.to_a, @options)
FileUtils.mkdir_p(File.dirname(dest_file))
File.open(dest_file, 'wb') { |fd| fd.write(rocco.to_html) }
end
task @name => dest_file
end
Return a FileList
that includes all of Roccos source files. This causes
output files to be regenerated properly when someone upgrades the Rocco
library.
def rocco_source_files
libdir = File.expand_path('../..', __FILE__)
FileList["#{libdir}/rocco.rb", "#{libdir}/rocco/**"]
end
end
end


Elif Sarikaya is a Fanshawe College student at Interactive Media Design program. She is from Turkey, has been living Canada for three years. She studied Mathematics back in Turkey. That's why she is interested in especially development part of this program. She wants to focus Js in the future.


Hi there! My name is Elaine, and I'm a recent Design Computing graduate from the University of Sydney.
I'm passionate about all things design, and am always looking for the next opportunity to be inspired.
UI design and UX research for a phone application that allows users to navigate an automated tour bus service.
Coming SoonA productivity companion designed to minimise stress and stimulate creativity through regularly timed 'mindless' breaks.
Coming SoonThe degree includes four design studios that focus on user experience (UX) design, interaction design, information visualisation, and interactive product design. Also developed other design technology skills through units such as Design Programming, Web Design & Technologies, Visual Communication, 3D Modelling & Fabrication, Principles of Animation, Designing with Colour, Film & Digital Media and Data Structures.


Documentary series on online hunt for Luka Magnotta coming to Netflix
A three-part documentary series about the online sleuths who helped track down the infamous killer Luka Magnotta is coming to Netflix.
The streaming service says the series will follow the story of internet users across the world who jumped into action after a video of an unknown man killing two kittens was posted online.
The online manhunt intensified as more disturbing videos were posted, including the infamous clip showing the dismemberment of 33-year-old university student Jun Lin.
The now 37-year-old Magnotta was convicted in December 2014 of first-degree murder in the slaying of Lin, as well as several other counts, and is currently serving a life sentence.

Netflix says the series, titled "Don't F**k With Cats: Hunting an Internet Killer," launches Dec. 18.


If you are interested in teaching mindfulness, the Sussex Mindfulness Centre offers the eight-week mindfulness based cognitive therapy (MBCT) course, as a first step in the training pathway.
This skills-based course will help guide you through practices and exercises that can help you get more out of life, and manage the ups and downs more skilfully. We have been running this course for staff in the NHS for almost 20 years.
What is mindfulness and how can it help?
Mindfulness training helps us to be more present with our experience, with an attitude of kindness and curiosity. This enables us to be less at the mercy of strong emotions and compelling thoughts and more able to respond in ways that are beneficial for ourselves and those around us.
You will learn:
- How to come out of autopilot so you are more able to respond to what is needed in the moment rather than react automatically in ways that might be harmful.
- Breathing Mindfulness practices to help you become more aware of your thoughts, emotions, physical sensations and impulses and which bring you back to responding clearly, effectively and in accordance with your values.
- To recognise what triggers and maintains stress and to respond in ways that support greater self-compassion and well-being, rather than self-criticism and agitation.
- Ways of responding skilfully to difficulties, such as conflicts or tricky relationships in ways that support understanding and care.
Some of the benefits include: decreased incidents of depression, reduced anxiety and stress, and improvements to sleep, memory and wellbeing.
What happens in the sessions?
In the two-hour sessions there will be a mixture of formal and informal mindfulness practices, discussion and exercises to help you reflect on your own experiences, and learn skills that you can apply in everyday life.
Mindfulness practices to do at home
The course includes daily breath and meditation mindfulness practices. Your teacher will give you links to these to guide you at home. Participants discover that the more home practice they do, the more likely they will feel the benefits of mindfulness.
Eight-week courses for you
You can access the course free of charge if you work for Sussex Partnership NHS Foundation Trust. If you do the free eight-week course via the Sussex Partnership, it still counts towards the eligibility criteria for training to teach mindfulness. For everybody else please see details of the next course below.
Eight-week mindfulness course
The next eight-week course will start on 14th September 2023.
- When: 6-8pm, 14th (orientation session), 21st and 28th September, 5th, 19th and 26th October, and 2nd, 9th and 15th November. (NB, no session 12th October.)
- Location: online
- Cost: £250. (If you go on to do the SMC Foundation or Adapted MBI training, the amount you paid for this eight-week course will be discounted from your training fee.)
- To apply: Please fill in this application form
- Buy your tickets here
NB. Please note that if you need to access mindfulness training for serious mental health issues, you should talk to your GP about being referred to the appropriate clinical service.
For enquiries: smc@spft.nhs.uk