Md. Ibrahim Khalil

ইসরাইলকে সন্ত্রাসী রাষ্ট্র ঘোষণা,,,,,,,,,,, ফিলিস্তিনিদের পাশে থাকবেন রিসেপ তায়েপ এরদোগান. তুর্কি. কাতার. পাকিস্তান. কুয়েত. আফগানিস্তান. মালয়েশিয়া. ইন্দোনেশিয়া. সৌদি আরব. দুবাই. মিশর. ইরান.#savepalestine#savethemuslims #StopTerrorismAgainstMuslims #AlAqsa #StopConspiracyAgainstIslam #StopIsraeliTerrorism#GazaUnderAttack#AlAqsaUnderAttack#WestandWithPalestine#PalestineWillBeFree#FreePalestine#StandForPalestine...  moreইসরাইলকে সন্ত্রাসী রাষ্ট্র ঘোষণা,,,,,,,,,,,
ফিলিস্তিনিদের পাশে থাকবেন
রিসেপ তায়েপ এরদোগান. তুর্কি. কাতার. পাকিস্তান. কুয়েত. আফগানিস্তান. মালয়েশিয়া. ইন্দোনেশিয়া. সৌদি আরব. দুবাই. মিশর. ইরান.#savepalestine
#savethemuslims #StopTerrorismAgainstMuslims #AlAqsa #StopConspiracyAgainstIslam #StopIsraeliTerrorism
#GazaUnderAttack
#AlAqsaUnderAttack
#WestandWithPalestine
#PalestineWillBeFree
#FreePalestine
#StandForPalestine
#StandWithSheikhJarrah
#savesheikhjarrah  

বাংলাদেশে সন্ত্রাস ও ধর্মীয় চরমপন্থা মোকাবিলায় প্রধানমন্ত্রী শেখ হাসিনার নেতৃত্বাধীন সরকারের প্রশংসা করেছে ইউরোপের শীর্ষস্থানীয় অলাভজনক সংস্থা ইউরোপিয়ান ফাউন্ডেশন ফর সাউথ এশিয়ান স্টাডিজ EFSAS - European Foundation for South Asian Studies

The owner of the cow used to hear dogs barking at night so he put one CCTV camera. And saw this unbelievable incident that one Leopard comes daily at night to meet the cow and the cow licks him with her tounge. The owner asked the previous owner of the Cow and came to know that the Leopard mom died when he was 20 days old and the cow fed her milk to the Leopard Since then the Leopard thinks that the cow is his mom.
And he comes daily at night to see her...

Android 12 Developer Preview 3 literally cuts corners.
Android is in for a huge design overhaul with version 12, and while many changes are still hidden, things are starting to come together in Android 12 Developer Preview 3, released yesterday. It enables the new thumb-friendly "silky home" by default for settings and adds smoother overflow animations across the OS, but there are also a few smaller design tweaks rounding everything out.

The changes can be seen across all of the OS. When you p...  moreAndroid 12 Developer Preview 3 literally cuts corners.
Android is in for a huge design overhaul with version 12, and while many changes are still hidden, things are starting to come together in Android 12 Developer Preview 3, released yesterday. It enables the new thumb-friendly "silky home" by default for settings and adds smoother overflow animations across the OS, but there are also a few smaller design tweaks rounding everything out.

The changes can be seen across all of the OS. When you pull up the app drawer on your homescreen, you'll notice rounder corners at the top as you move up the panel. Similarly, app previews in the multitasking overview also come with much rounder corners. The volume slider is in for an even more significant redesign, much like a redone brightness slider that popped up in a previous developer preview. It's now a rounded vertical pill, filled with your accent color depicting the current volume level. The live transcribe button below it is still stuck with the old square-ish design, so it looks like the menu is a work in progress and still up for change. Pop-up windows have also received the rounded corner makeover.

Android 12 has also introduced a few more changes compared to previous OS versions. Homescreen folders come with rounded corners, and the long-press menu has been reworked in a similar fashion. Text selection and context menus also come in the form of rounded pills now, making clear that Google is moving to unify the look of its OS even further.

It's possible that some of these interface tweaks aren't finalized just yet, so we might see even more visual changes once the first beta launches at Google I/O next month.  

7 JavaScript Best Practices to Improve Code Quality
Learn how some of the new features in JavaScript can help you write cleaner code.
If you write JavaScript today, it’s worth your time staying in the know of all the updates the language has seen in the past few years. Since 2015, with the release of ES6, a new version of the ECMAScript spec has been released each year. Each iteration adds new features, new syntax, and Quality of Life improvements to the language. JavaScript engines in most br...  more7 JavaScript Best Practices to Improve Code Quality
Learn how some of the new features in JavaScript can help you write cleaner code.
If you write JavaScript today, it’s worth your time staying in the know of all the updates the language has seen in the past few years. Since 2015, with the release of ES6, a new version of the ECMAScript spec has been released each year. Each iteration adds new features, new syntax, and Quality of Life improvements to the language. JavaScript engines in most browsers and Node.js quickly catch up, and it’s only fair that your code should catch up as well. That’s because with each new iteration of JavaScript comes new idioms and new ways to express your code, and many a time, these changes may make the code more maintainable for you and your collaborators.

Here are some of the latest ECMAScript features, and by induction, JavaScript and Node.js that you can make use of to write cleaner, more concise, and more readable code.

1. Block Scored Declarations
Since the inception of the language, JavaScript developers have used var to declare variables. The keyword var has its quirks, the most problematic of those being the scope of the variables created by using it.

var x = 10
if (true) {
var x = 15 // inner declaration overrides declaration in parent scope
console.log(x) // prints 15
}
console.log(x) // prints 15

Since variables defined with var are not block-scoped, redefining them in a narrower scope affects the value of the outer scope.

Now we have two new keywords that replace var, namely let and const that do not suffer from this drawback.

let y = 10
if (true) {
let y = 15 // inner declaration is scoped within the if block
console.log // prints 15
}
console.log // prints 10

const and let differ in the semantics that variables declared with const cannot be reassigned in their scope. This does not mean they are immutable, only that their references cannot be changed.

const x = []

x.push("Hello", "World!"
x // ["Hello", "World!"]

x = [] // TypeError: Attempted to assign to readonly property.

2. Arrow Functions
Arrow functions are another very important feature introduced recently to JavaScript. They come bearing many advantages. First and foremost, they make the functional aspects of JavaScript beautiful to look at and simpler to write.

let x = [1, 2, 3, 4]

x.map(val => val * 2) // [2, 4, 6, 8]
x.filter(val => val % 2 == 0) // [2, 4]
x.reduce((acc, val) => acc + val, 0) // 10

In all of the above examples the arrow functions, named after the distinctive arrow =>, replace traditional functions with a concise syntax.

If the function body is a single expression, the scope brackets {} and return keywords are implied and need not be written.
If the function has a single argument, the argument parentheses () are implied and need not be written.
If the function body expression is a dictionary, it must be enclosed in parentheses ().
Another significant advantage of arrow functions is that they do not define a scope but rather exist within the parent scope. This avoids a lot of pitfalls that can arise with the use of the this keyword. Arrow functions have no bindings for this. Inside the arrow function, the value of this is the same as that in the parent scope. Consequently, arrow functions cannot be used as methods or constructors. Arrow functions don’t work with apply, bind, or call and have no bindings for super.

They also have certain other limitations such as lack of the arguments object which traditional functions can access and the inability to yield from the function body.

Thus arrow functions are not a 1:1 replacement for standard functions but welcome addition to JavaScript’s feature set.

3. Optional Chaining
Imagine a deeply nested data structure like this person object here. Consider you wanted to access the first and last name of this person. You would write this in JavaScript like so:

person = {
name: {
first: 'John',
last: 'Doe',
},
age: 42
}
person.name.first // 'John'
person.name.last // 'Doe'

Now imagine what would happen if the person object did not contain a nested name object.

person = {
age: 42
}
person.name.first // TypeError: Cannot read property 'first' of undefined
person.name.last // TypeError: Cannot read property 'last' of undefined

To avoid such errors, developers had to resort to code like the following, which is unnecessarily verbose, hard to read, and unpleasant to write — a very bad trio of adjectives.

person && person.name && person.name.first // undefined

Meet optional chaining, a new feature of JavaScript that does away with this monstrosity. Optional chaining short-circuits the digging process as soon as it encounters a null or undefined value and returns undefined without raising an error.

person?.name?.first // undefined

The resultant code is much concise and cleaner.

4. Null-ish Coalescing
Before introducing the null-ish coalescing operator, JavaScript developers used the OR operator || to fall back to a default value if the input was absent. This came with a significant caveat that even legitimate but falsy values would result in a fallback to the defaults.

function print(val) {
return val || 'Missing'
}

print(undefined) // 'Missing'
print(null) // 'Missing'

print(0) // 'Missing'
print('&#039 // 'Missing'
print(false) // 'Missing'
print(NaN) // 'Missing'

JavaScript has now proposed the null coalescing operator ??, which offers a better alternative in that it only results in a fallback if the preceding expression is null-ish. Here null-ish refers to values that are null or undefined.

function print(val) {
return val ?? 'Missing'
}

print(undefined) // 'Missing'
print(null) // 'Missing'

print(0) // 0
print('&#039 // ''
print(false) // false
print(NaN) // NaN

This way, you can ensure that if your program accepts falsy values as legitimate inputs, you won’t end up replacing them with fallbacks.

5. Logical Assignment
Let’s say you want to assign a value to a variable if and only if the value is currently null-ish. A logical way to write this would be like so:

if (x === null || x == undefined) {
x = y
}

If you knew about how short-circuiting works, you might want to replace those 3 lines of code with a more succinct version using the null-ish coalescing operator.

x ?? (x = y) // x = y if x is nullish, else no effect

Here we use the short-circuiting feature of the null-ish coalescing operator to execute the second part x = y if x is null-ish. The code is pretty concise, but it still is not very easy to read or understand. The logical null-ish assignment does away with the need for such a workaround.

x ??= y // x = y if x is nullish, else no effect

Along the same lines, JavaScript also introduces logical AND assignment &&= and logical OR assignment ||= operators. These operators perform assignments only when the specific condition is met and have no effect otherwise.

x ||= y // x = y if x is falsy, else no effect
x &&= y // x = y if x is truthy, else no effect

Pro-tip: If you’ve written Ruby before, you’ve seen the ||= and &&= operators, since Ruby does not have the concept of falsy values.

6. Named Capture Groups
Let’s start with a quick recap of capture groups in regular expressions. A capture group is a part of the string that matches a portion of regex in parentheses.

let re = /(\d{4})-(\d{2})-(\d{2})/
let result = re.exec('Pi day this year falls on 2021-03-14!&#039

result[0] // '2020-03-14', the complete match
result[1] // '2020', the first capture group
result[2] // '03', the second capture group
result[3] // '14', the third capture group

Regular expressions have also supported named capture groups for quite some time, which is a way for the capture groups to be referenced by a name rather than an index. Now, with ES9, this feature has made its way to JavaScript. Now the result object contains a nested groups object where each capture group’s value is mapped to its name.

let re = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/
let result = re.exec('Pi day this year falls on 2021-03-14!&#039

result.groups.year // '2020', the group named 'year'
result.groups.month // '03', the group named 'month'
result.groups.day // '14', the group named 'day'

The new API works beautifully with another new JavaScript feature, de-structured assignments.

let re = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/
let result = re.exec('Pi day this year falls on 2021-03-14!&#039
let { year, month, day } = result.groups

year // '2020'
month // '03'
day // '14'

7. async and await
One of the powerful aspects of JavaScript is its asynchronicity. This means that many functions that may be long-running or time-consuming can return a Promise and not block execution.

const url = 'https://the-one-api.dev/v2/book&apos;
let prom = fetch(url)
prom // Promise {<pending>}

// wait a bit
prom // Promise {<fullfilled>: Response}, if no errors
// or
prom // Promise {<rejected>: Error message}, if any error

Here the call to fetch returns a Promise that has the status ‘pending’ when created. Soon, when the API returns the response, it transitions into a ‘fulfilled’ state, and the Response that it wraps can be accessed. In the Promises world, you would do something like this to make an API call and parse the response as JSON.

const url = 'https://the-one-api.dev/v2/book&apos;
let prom = fetch(url)
prom // Promise {<fullfilled>: Response}
.then(res => res.json())
.then(json => console.log(json)) // prints response, if no errors
.catch(err => console.log(err)) // prints error message, if any error

In 2017, JavaScript announced two new keywords async and await, that makes handling and working with Promises easier and more fluent. They are not a replacement for Promises; they are merely syntactic sugar on top of the powerful Promises concepts.

Instead of all the code happening inside a series of ‘then’ functions, await makes it all look like synchronous JavaScript. As an added benefit, you can use try...catch with await instead of handling errors in ‘catch’ functions as you would have to if consuming Promises directly. The same code with await would look like this.

const url = 'https://the-one-api.dev/v2/book&apos;
let res = await fetch(url) // Promise {<fullfilled>: Response} -await-> Response
try {
let json = await res.json()
console.log(json) // prints response, if no errors
} catch(err) {
console.log(err) // prints error message, if any error
}

The async keyword is the other side of the same coin, in that it wraps any data to be sent within a Promise. Consider the following asynchronous function for adding several numbers. In the real world, your code would be doing something much more complicated.

async function sum(...nums) {
return nums.reduce((agg, val) => agg + val, 0)
}

sum(1, 2, 3) // Promise {<fulfilled>: 6}
.then(res => console.log(res) // prints 6

let res = await sum(1, 2, 3) // Promise {<fulfilled>: 6} -await-> 6
console.log(res) // prints 6
Conclusion
These new features just the tip of the iceberg. We have barely even scratched the surface. JavaScript is constantly evolving, and new features are added to the language every year. It’s tough to keep up with the constant barrage of new features and idioms introduced to the language manually.

Wouldn’t it be nice if some tool could handle this for us? Fret not, there is. We’ve already talked in detail about setting up static code analysis in your JavaScript repo using ESLint. It’s extremely useful and should be an indispensable tool of your toolchain. But to be honest, setting up ESLint auto-fix pipelines and processes takes time and effort. Unless you enjoy this sort of plumbing, you’d be better off if you wrote the code and outsourced the plumbing to… DeepSource!

DeepSource can help you with automating the code reviews and save you a ton of time. Just add a .deepsource.toml file in the root of the repository and DeepSource will pick it up for scanning right away. The scan will find scope for improvements across your code and help you fix them with helpful descriptions.  

State of JavaScript survey: Svelte and Nuxt good, Angular and Cordova bad

James is editor in chief of TechForge Media, with a passion for how technologies influence business and several Mobile World Congress events under his belt. James has interviewed a variety of leading figures in his career, from former Mafia boss Michael Franzese, to Steve Wozniak, and Jean Michel Jarre. James can be found tweeting at @James_T_Bourne.
The latest survey data assessing the JavaScript ecosystem is in, with a...  moreState of JavaScript survey: Svelte and Nuxt good, Angular and Cordova bad

James is editor in chief of TechForge Media, with a passion for how technologies influence business and several Mobile World Congress events under his belt. James has interviewed a variety of leading figures in his career, from former Mafia boss Michael Franzese, to Steve Wozniak, and Jean Michel Jarre. James can be found tweeting at @James_T_Bourne.
The latest survey data assessing the JavaScript ecosystem is in, with a heady mix of winners and losers – but a continuing stream of innovation in features and libraries.

The 2019 State of JavaScript study, published at the end of last month, saw more than 21,000 respondents – albeit more than 91% were male – with two thirds (64%) having between two and 10 years’ experience with the language.

When it came to the different technologies and how satisfied respondents were, the results were based on usage as well as happiness. User interface library React, Node.js framework Express and testing product Jest scored highly on both metrics – more than 60% usage and 90% satisfaction – with TypeScript outside. In the bottom right ‘analyse’ category – in other words, get your head analysed if you’re using this – only Angular, which extends HTML frameworks, saw a place, with below 40% satisfaction and almost 60% usage.

Cordova, the mobile app framework formerly known as PhoneGap, was something of a curate’s egg. Satisfaction with the product was at 28% – only Meteor and Sails scored worse – with usage at just over 30%, seeing a gradual if not precipitous decline since 2016.

For those technologies at the lower end but seeing a positive uptick, Svelte and Nuxt stood out. Svelte, a web app framework which has been compared favourably to React, was named as the most popular write-in for the 2018 State of JavaScript report. Nuxt, meanwhile, is a Vue.js web application framework. The former had 87.6% satisfaction with fewer than 10% adoption, while the latter hit 88.5% at approximately 12.5% adoption.

In terms of syntax and grammar on JavaScript, standardisation was almost uniform. 97% of those polled said they used arrow functions, with this number dropping slightly to 89.5% for spread syntax and 85% for destructuring. For language itself, there was greater division. Some terms, such as proxy objects – used to define custom behaviour for fundamental operations – had 43% of respondents unfamiliar with it. Others, such as decorators, wrapping one piece of code with another, had 25% unfamiliarity but an almost even mix on usage (37.9% for, 37.4% against).

The research also explored the usage of various browser APIs and again found a mix of responses. Fetch, as well as the local storage property, were particularly popular with 81.5% and 88% usage respectively. The WebSocket API saw solid uptake with 59.2% usage and only 7% who had either never heard of it or were unsure. Yet for WebGL and WebRTC, two standards which have previously generated considerable noise, the indifference was palpable. 43% of those polled were unsure around WebRTC with only one in 10 using it, while WebGL had a more definitive refusal; more than two thirds (68.6%) said they did not use it.

The report authors, Sacha Greif and Raphael Benitte, admitted that 2018 would be the last year of the study. How much could an almost 25-year-old language keep changing year over year, after all? Yet with Svelte, Nuxt and others, enough innovation is taking place in the JS world. “No matter how many weirdly-named libraries the community keeps throwing at you, we’ll be there to help make sense of all this chaos,” the authors noted.

You can take a look at the full report and data by visiting here.

Interested in hearing industry leaders discuss subjects like this and sharing their use-cases? Attend the co-located 5G Expo, IoT Tech Expo, Blockchain Expo, AI & Big Data Expo, and Cyber Security & Cloud Expo World Series with upcoming events in Silicon Valley, London, and Amsterdam.

 

O’Reilly: Python leads languages, React for web development, and ML/AI interest grows
Education giant O’Reilly has released data about its online platform which highlights some interesting software development trends.

The headline finding is that Python continues to be the programming language with the most interest.

Given the growth in topics relating to Python such as AI – and the language often considered the best to pick up for new developers – it’ll perhaps come of little surprise to hea...  moreO’Reilly: Python leads languages, React for web development, and ML/AI interest grows
Education giant O’Reilly has released data about its online platform which highlights some interesting software development trends.

The headline finding is that Python continues to be the programming language with the most interest.

Given the growth in topics relating to Python such as AI – and the language often considered the best to pick up for new developers – it’ll perhaps come of little surprise to hear of its popularity.

Israel-based startup Codota has raised $12 million (£9.6m) in a series A funding round to build on its AI-flavoured product which aims to improve developer productivity.

The company's platform aims to be the dev equivalent of Gmail's Smart Compose, providing suggestions to coders based on an analysis of 'millions' of code repositories. In the company's own words, it 'automates all predictable parts of the development cycle, such as looking up syntax and applying the best...